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

#include "include/core/SkM44.h"
#include "modules/skottie/src/Adapter.h"
#include "modules/skottie/src/SkottieJson.h"
#include "modules/skottie/src/SkottiePriv.h"
#include "modules/skottie/src/SkottieValue.h"
#include "modules/skottie/src/layers/shapelayer/ShapeLayer.h"
#include "modules/sksg/include/SkSGGeometryEffect.h"
#include "src/core/SkGeometry.h"

#include <vector>

namespace skottie::internal {

namespace  {

static SkPoint lerp(const SkPoint& p0, const SkPoint& p1, SkScalar t) {
    return p0 + (p1 - p0) * t;
}

// Operates on the cubic representation of a shape.  Pulls vertices towards the shape center,
// and cubic control points away from the center.  The general shape center is the vertex average.
class PuckerBloatEffect final : public sksg::GeometryEffect {
public:
    explicit PuckerBloatEffect(sk_sp<sksg::GeometryNode> geo) : INHERITED({std::move(geo)}) {}

    // Fraction of the transition to center. I.e.
    //
    //     0 -> no effect
    //     1 -> vertices collapsed to center
    //
    // Negative values are allowed (inverse direction), as are extranormal values.
    SG_ATTRIBUTE(Amount, float, fAmount)

private:
    SkPath onRevalidateEffect(const sk_sp<GeometryNode>& geo) override {
        struct CubicInfo {
            SkPoint ctrl0, ctrl1, pt; // corresponding to SkPath::cubicTo() params, respectively.
        };

        const auto input = geo->asPath();
        if (SkScalarNearlyZero(fAmount)) {
            return input;
        }

        const auto input_bounds = input.computeTightBounds();
        const SkPoint center{input_bounds.centerX(), input_bounds.centerY()};

        SkPath path;

        SkPoint contour_start = {0, 0};
        std::vector<CubicInfo> cubics;

        auto commit_contour = [&]() {
            path.moveTo(lerp(contour_start, center, fAmount));
            for (const auto& c : cubics) {
                path.cubicTo(lerp(c.ctrl0, center, -fAmount),
                             lerp(c.ctrl1, center, -fAmount),
                             lerp(c.pt   , center,  fAmount));
            }
            path.close();

            cubics.clear();
        };

        // Normalize all verbs to cubic representation.
        SkPoint pts[4];
        SkPath::Verb verb;
        SkPath::Iter iter(input, true);
        while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
            switch (verb) {
                case SkPath::kMove_Verb:
                    commit_contour();
                    contour_start = pts[0];
                    break;
                case SkPath::kLine_Verb: {
                    // Empirically, straight lines are treated as cubics with control points
                    // located length/100 away from extremities.
                    static constexpr float kCtrlPosFraction = 1.f / 100;
                    const auto line_start = pts[0],
                               line_end   = pts[1];
                    cubics.push_back({
                            lerp(line_start, line_end,     kCtrlPosFraction),
                            lerp(line_start, line_end, 1 - kCtrlPosFraction),
                            line_end
                    });
                } break;
                case SkPath::kQuad_Verb:
                    SkConvertQuadToCubic(pts, pts);
                    cubics.push_back({pts[1], pts[2], pts[3]});
                    break;
                case SkPath::kConic_Verb: {
                    // We should only ever encounter conics from circles/ellipses.
                    SkASSERT(SkScalarNearlyEqual(iter.conicWeight(), SK_ScalarRoot2Over2));

                    // http://spencermortensen.com/articles/bezier-circle/
                    static constexpr float kCubicCircleCoeff = 1 - 0.551915024494f;

                    const auto conic_start = cubics.empty() ? contour_start
                                                            : cubics.back().pt,
                               conic_end   = pts[2];

                    cubics.push_back({
                        lerp(pts[1], conic_start, kCubicCircleCoeff),
                        lerp(pts[1], conic_end  , kCubicCircleCoeff),
                        conic_end
                    });
                } break;
                case SkPath::kCubic_Verb:
                    cubics.push_back({pts[1], pts[2], pts[3]});
                    break;
                case SkPath::kClose_Verb:
                    commit_contour();
                    break;
                default:
                    break;
            }
        }

        return path;
    }

    float fAmount = 0;

    using INHERITED = sksg::GeometryEffect;
};

class PuckerBloatAdapter final : public DiscardableAdapterBase<PuckerBloatAdapter,
                                                               PuckerBloatEffect> {
public:
    PuckerBloatAdapter(const skjson::ObjectValue& joffset,
                       const AnimationBuilder& abuilder,
                       sk_sp<sksg::GeometryNode> child)
        : INHERITED(sk_make_sp<PuckerBloatEffect>(std::move(child))) {
        this->bind(abuilder, joffset["a" ], fAmount);
    }

private:
    void onSync() override {
        // AE amount is percentage-based.
        this->node()->setAmount(fAmount / 100);
    }

    ScalarValue fAmount = 0;

    using INHERITED = DiscardableAdapterBase<PuckerBloatAdapter, PuckerBloatEffect>;
};

} // namespace

std::vector<sk_sp<sksg::GeometryNode>> ShapeBuilder::AttachPuckerBloatGeometryEffect(
        const skjson::ObjectValue& jround, const AnimationBuilder* abuilder,
        std::vector<sk_sp<sksg::GeometryNode>>&& geos) {
    std::vector<sk_sp<sksg::GeometryNode>> bloated;
    bloated.reserve(geos.size());

    for (auto& g : geos) {
        bloated.push_back(abuilder->attachDiscardableAdapter<PuckerBloatAdapter>
                                        (jround, *abuilder, std::move(g)));
    }

    return bloated;
}

} // namespace skottie::internal