/*
 * Copyright 2019 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "modules/skottie/src/text/TextAnimator.h"

#include "include/core/SkColor.h"
#include "include/core/SkPoint.h"
#include "include/private/SkNx.h"
#include "modules/skottie/src/text/RangeSelector.h"
#include "modules/skottie/src/text/TextAdapter.h"
#include "src/utils/SkJSON.h"

namespace skottie {
namespace internal {

/*
 * Text layers can have optional text property animators.
 *
 * Each animator consists of
 *
 *   1) a list of animated properties (e.g. position, fill color, etc)
 *
 *   2) a list of range selectors
 *
 * Animated properties yield new values to be applied to the text, while range selectors
 * determine the text subset these new values are applied to.
 *
 * The best way to think of range selectors is in terms of coverage: they combine to generate
 * a coverage value [0..1] for each text fragment/glyph.  This coverage is then used to modulate
 * how the new property value is applied to a given fragment (interpolation weight).
 *
 * Note: Bodymovin currently only supports a single selector.
 *
 * JSON structure:
 *
 * "t": {              // text node
 *   "a": [            // animators list
 *     {               // animator node
 *       "s": {...},   // selector node (TODO)
 *       "a": {        // animator properties node
 *         "a":  {}    // optional anchor point value
 *         "p":  {},   // optional position value
 *         "s":  {},   // optional scale value
 *         "o":  {},   // optional opacity
 *         "fc": {},   // optional fill color value
 *         "sc": {},   // optional stroke color value
 *
 *         // TODO: more props?
 *       }
 *     },
 *     ...
 *   ],
 *   ...
 * }
 */
sk_sp<TextAnimator> TextAnimator::Make(const skjson::ObjectValue* janimator,
                                       const AnimationBuilder* abuilder) {
    if (!janimator) {
        return nullptr;
    }

    std::vector<sk_sp<RangeSelector>> selectors;
    if (const skjson::ObjectValue* jselector = (*janimator)["s"]) {
        // Single range selector for now.
        if (auto sel = RangeSelector::Make(jselector, abuilder)) {
            selectors.reserve(1);
            selectors.push_back(std::move(sel));
        }
    }

    const skjson::ObjectValue* jprops = (*janimator)["a"];

    return jprops
        ? sk_sp<TextAnimator>(new TextAnimator(std::move(selectors), *jprops, abuilder))
        : nullptr;
}

void TextAnimator::modulateProps(const DomainMaps& maps, ModulatorBuffer& buf) const {
    // Coverage is scoped per animator.
    for (auto& mod : buf) {
        mod.coverage = 0;
    }

    // Accumulate selector coverage.
    for (const auto& selector : fSelectors) {
        selector->modulateCoverage(maps, buf);
    }

    // Modulate animated props.
    for (auto& mod : buf) {
        mod.props = this->modulateProps(mod.props, mod.coverage);
    }
}

TextAnimator::AnimatedProps TextAnimator::modulateProps(const AnimatedProps& props,
                                                        float amount) const {
    auto modulated_props = props;

    // Transform props compose.
    modulated_props.position += fTextProps.position * amount;
    modulated_props.rotation += fTextProps.rotation * amount;
    modulated_props.tracking += fTextProps.tracking * amount;
    modulated_props.scale    *= 1 + (fTextProps.scale - 1) * amount;

    const auto lerp_color = [](SkColor c0, SkColor c1, float t) {
        const auto c0_4f = SkNx_cast<float>(Sk4b::Load(&c0)),
                   c1_4f = SkNx_cast<float>(Sk4b::Load(&c1)),
                    c_4f = c0_4f + (c1_4f - c0_4f) * t;

        SkColor c;
        SkNx_cast<uint8_t>(Sk4f_round(c_4f)).store(&c);
        return c;
    };

    // Colors and opacity are overridden, and use a clamped amount value.
    const auto clamped_amount = std::max(amount, 0.0f);
    if (fHasFillColor) {
        modulated_props.fill_color = lerp_color(props.fill_color,
                                                fTextProps.fill_color,
                                                clamped_amount);
    }
    if (fHasStrokeColor) {
        modulated_props.stroke_color = lerp_color(props.stroke_color,
                                                  fTextProps.stroke_color,
                                                  clamped_amount);
    }
    modulated_props.opacity *= 1 + (fTextProps.opacity - 1) * clamped_amount;

    return modulated_props;
}

TextAnimator::TextAnimator(std::vector<sk_sp<RangeSelector>>&& selectors,
                           const skjson::ObjectValue& jprops,
                           const AnimationBuilder* abuilder)
    : fSelectors(std::move(selectors)) {

    // It's *probably* OK to capture a raw pointer to this animator, because the lambda
    // life time is limited to |ascope|, which is also the container for the TextAnimatorList
    // owning us. But for peace of mind (and future-proofing) let's grab a ref.
    auto animator = sk_ref_sp(this);

    abuilder->bindProperty<VectorValue>(jprops["p"],
        [animator](const VectorValue& p) {
            animator->fTextProps.position = ValueTraits<VectorValue>::As<SkPoint>(p);
        });
    abuilder->bindProperty<ScalarValue>(jprops["s"],
        [animator](const ScalarValue& s) {
            // Scale is 100-based.
            animator->fTextProps.scale = s * 0.01f;
        });
    abuilder->bindProperty<ScalarValue>(jprops["r"],
        [animator](const ScalarValue& r) {
            animator->fTextProps.rotation = r;
        });
    fHasFillColor   = abuilder->bindProperty<VectorValue>(jprops["fc"],
        [animator](const VectorValue& fc) {
            animator->fTextProps.fill_color = ValueTraits<VectorValue>::As<SkColor>(fc);
        });
    fHasStrokeColor = abuilder->bindProperty<VectorValue>(jprops["sc"],
        [animator](const VectorValue& sc) {
            animator->fTextProps.stroke_color = ValueTraits<VectorValue>::As<SkColor>(sc);
        });
    abuilder->bindProperty<ScalarValue>(jprops["o"],
        [animator](const ScalarValue& o) {
            // Opacity is 100-based.
            animator->fTextProps.opacity = SkTPin<float>(o * 0.01f, 0, 1);
        });
    abuilder->bindProperty<ScalarValue>(jprops["t"],
        [animator](const ScalarValue& t) {
            animator->fTextProps.tracking = t;
        });
}

sk_sp<TextAnimatorList> TextAnimatorList::Make(const skjson::ArrayValue& janimators,
                                               const AnimationBuilder* abuilder,
                                               sk_sp<TextAdapter> adapter) {
    AnimationBuilder::AutoScope ascope(abuilder);
    std::vector<sk_sp<TextAnimator>> animators;
    animators.reserve(janimators.size());

    for (const skjson::ObjectValue* janimator : janimators) {
        if (auto animator = TextAnimator::Make(janimator, abuilder)) {
            animators.push_back(std::move(animator));
        }
    }

    auto local_animator_scope = ascope.release();

    if (animators.empty()) {
        return nullptr;
    }

    return sk_sp<TextAnimatorList>(new TextAnimatorList(std::move(adapter),
                                                        std::move(local_animator_scope),
                                                        std::move(animators)));
}

TextAnimatorList::TextAnimatorList(sk_sp<TextAdapter> adapter,
                                   sksg::AnimatorList&& alist,
                                   std::vector<sk_sp<TextAnimator>>&& tanimators)
    : INHERITED(std::move(alist))
    , fAnimators(std::move(tanimators))
    , fAdapter(std::move(adapter)) {}

TextAnimatorList::~TextAnimatorList() = default;

void TextAnimatorList::onTick(float t) {
    // First, update all locally-scoped animated props.
    this->INHERITED::onTick(t);

    // Then push the final property values to the text adapter.
    fAdapter->applyAnimators(fAnimators);
}

} // namespace internal
} // namespace skottie