/*

 * Copyright 2018 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/layers/shapelayer/ShapeLayer.h"

#include "include/core/SkPath.h"

#include "modules/skottie/src/SkottieJson.h"

#include "modules/skottie/src/SkottiePriv.h"

#include "modules/skottie/src/SkottieValue.h"

#include "modules/sksg/include/SkSGDraw.h"

#include "modules/sksg/include/SkSGGeometryEffect.h"

#include "modules/sksg/include/SkSGGroup.h"

#include "modules/sksg/include/SkSGMerge.h"

#include "modules/sksg/include/SkSGPaint.h"

#include "modules/sksg/include/SkSGPath.h"

#include "modules/sksg/include/SkSGRect.h"

#include "modules/sksg/include/SkSGRenderEffect.h"

#include "modules/sksg/include/SkSGTransform.h"

#include "src/utils/SkJSON.h"

#include <algorithm>

#include <iterator>

namespace skottie {

namespace internal {

namespace {

using GeometryAttacherT = sk_sp<sksg::GeometryNode> (*)(const skjson::ObjectValue&,

                                                        const AnimationBuilder*);

static constexpr GeometryAttacherT gGeometryAttachers[] = {

    ShapeBuilder::AttachPathGeometry,

    ShapeBuilder::AttachRRectGeometry,

    ShapeBuilder::AttachEllipseGeometry,

    ShapeBuilder::AttachPolystarGeometry,

};

using GeometryEffectAttacherT =

    std::vector<sk_sp<sksg::GeometryNode>> (*)(const skjson::ObjectValue&,

                                               const AnimationBuilder*,

                                               std::vector<sk_sp<sksg::GeometryNode>>&&);

static constexpr GeometryEffectAttacherT gGeometryEffectAttachers[] = {

    ShapeBuilder::AttachMergeGeometryEffect,

    ShapeBuilder::AttachTrimGeometryEffect,

    ShapeBuilder::AttachRoundGeometryEffect,

    ShapeBuilder::AttachOffsetGeometryEffect,

    ShapeBuilder::AttachPuckerBloatGeometryEffect,

};

using PaintAttacherT = sk_sp<sksg::PaintNode> (*)(const skjson::ObjectValue&,

                                                  const AnimationBuilder*);

static constexpr PaintAttacherT gPaintAttachers[] = {

    ShapeBuilder::AttachColorFill,

    ShapeBuilder::AttachColorStroke,

    ShapeBuilder::AttachGradientFill,

    ShapeBuilder::AttachGradientStroke,

};

// Some paint types (looking at you dashed-stroke) mess with the local geometry.

static constexpr GeometryEffectAttacherT gPaintGeometryAdjusters[] = {

    nullptr,                             // color fill

    ShapeBuilder::AdjustStrokeGeometry,  // color stroke

    nullptr,                             // gradient fill

    ShapeBuilder::AdjustStrokeGeometry,  // gradient stroke

};

static_assert(SK_ARRAY_COUNT(gPaintGeometryAdjusters) == SK_ARRAY_COUNT(gPaintAttachers), "");

using DrawEffectAttacherT =

    std::vector<sk_sp<sksg::RenderNode>> (*)(const skjson::ObjectValue&,

                                             const AnimationBuilder*,

                                             std::vector<sk_sp<sksg::RenderNode>>&&);

static constexpr DrawEffectAttacherT gDrawEffectAttachers[] = {

    ShapeBuilder::AttachRepeaterDrawEffect,

};

enum class ShapeType {

    kGeometry,

    kGeometryEffect,

    kPaint,

    kGroup,

    kTransform,

    kDrawEffect,

};

enum ShapeFlags : uint16_t {

    kNone          = 0x00,

    kSuppressDraws = 0x01,

};

struct ShapeInfo {

    const char* fTypeString;

    ShapeType   fShapeType;

    uint16_t    fAttacherIndex; // index into respective attacher tables

    uint16_t    fFlags;

};

const ShapeInfo* FindShapeInfo(const skjson::ObjectValue& jshape) {

    static constexpr ShapeInfo gShapeInfo[] = {

        { "el", ShapeType::kGeometry      , 2, kNone          }, // ellipse

        { "fl", ShapeType::kPaint         , 0, kNone          }, // fill

        { "gf", ShapeType::kPaint         , 2, kNone          }, // gfill

        { "gr", ShapeType::kGroup         , 0, kNone          }, // group

        { "gs", ShapeType::kPaint         , 3, kNone          }, // gstroke

        { "mm", ShapeType::kGeometryEffect, 0, kSuppressDraws }, // merge

        { "op", ShapeType::kGeometryEffect, 3, kNone          }, // offset

        { "pb", ShapeType::kGeometryEffect, 4, kNone          }, // pucker/bloat

        { "rc", ShapeType::kGeometry      , 1, kNone          }, // rrect

        { "rd", ShapeType::kGeometryEffect, 2, kNone          }, // round

        { "rp", ShapeType::kDrawEffect    , 0, kNone          }, // repeater

        { "sh", ShapeType::kGeometry      , 0, kNone          }, // shape

        { "sr", ShapeType::kGeometry      , 3, kNone          }, // polystar

        { "st", ShapeType::kPaint         , 1, kNone          }, // stroke

        { "tm", ShapeType::kGeometryEffect, 1, kNone          }, // trim

        { "tr", ShapeType::kTransform     , 0, kNone          }, // transform

    };

    const skjson::StringValue* type = jshape["ty"];

    if (!type) {

        return nullptr;

    }

    const auto* info = bsearch(type->begin(),

                               gShapeInfo,

                               SK_ARRAY_COUNT(gShapeInfo),

                               sizeof(ShapeInfo),

                               [](const void* key, const void* info) {

                                  return strcmp(static_cast<const char*>(key),

                                                static_cast<const ShapeInfo*>(info)->fTypeString);

                               });

    return static_cast<const ShapeInfo*>(info);

}

struct GeometryEffectRec {

    const skjson::ObjectValue& fJson;

    GeometryEffectAttacherT    fAttach;

};

} // namespace

sk_sp<sksg::GeometryNode> ShapeBuilder::AttachPathGeometry(const skjson::ObjectValue& jpath,

                                                           const AnimationBuilder* abuilder) {

    return abuilder->attachPath(jpath["ks"]);

}

struct AnimationBuilder::AttachShapeContext {

    AttachShapeContext(std::vector<sk_sp<sksg::GeometryNode>>* geos,

                       std::vector<GeometryEffectRec>* effects,

                       size_t committedAnimators)

        : fGeometryStack(geos)

        , fGeometryEffectStack(effects)

        , fCommittedAnimators(committedAnimators) {}

    std::vector<sk_sp<sksg::GeometryNode>>* fGeometryStack;

    std::vector<GeometryEffectRec>*         fGeometryEffectStack;

    size_t                                  fCommittedAnimators;

};

sk_sp<sksg::RenderNode> AnimationBuilder::attachShape(const skjson::ArrayValue* jshape,

                                                      AttachShapeContext* ctx,

                                                      bool suppress_draws) const {

    if (!jshape)

        return nullptr;

    SkDEBUGCODE(const auto initialGeometryEffects = ctx->fGeometryEffectStack->size();)

    const skjson::ObjectValue* jtransform = nullptr;

    struct ShapeRec {

        const skjson::ObjectValue& fJson;

        const ShapeInfo&           fInfo;

        bool                       fSuppressed;

    };

    // First pass (bottom->top):

    //

    //   * pick up the group transform and opacity

    //   * push local geometry effects onto the stack

    //   * store recs for next pass

    //

    std::vector<ShapeRec> recs;

    for (size_t i = 0; i < jshape->size(); ++i) {

        const skjson::ObjectValue* shape = (*jshape)[jshape->size() - 1 - i];

        if (!shape) continue;

        const auto* info = FindShapeInfo(*shape);

        if (!info) {

            this->log(Logger::Level::kError, &(*shape)["ty"], "Unknown shape.");

            continue;

        }

        if (ParseDefault<bool>((*shape)["hd"], false)) {

            // Ignore hidden shapes.

            continue;

        }

        recs.push_back({ *shape, *info, suppress_draws });

        // Some effects (merge) suppress any paints above them.

        suppress_draws |= (info->fFlags & kSuppressDraws) != 0;

        switch (info->fShapeType) {

        case ShapeType::kTransform:

            // Just track the transform property for now -- we'll deal with it later.

            jtransform = shape;

            break;

        case ShapeType::kGeometryEffect:

            SkASSERT(info->fAttacherIndex < SK_ARRAY_COUNT(gGeometryEffectAttachers));

            ctx->fGeometryEffectStack->push_back(

                { *shape, gGeometryEffectAttachers[info->fAttacherIndex] });

            break;

        default:

            break;

        }

    }

    // Second pass (top -> bottom, after 2x reverse):

    //

    //   * track local geometry

    //   * emit local paints

    //

    std::vector<sk_sp<sksg::GeometryNode>> geos;

    std::vector<sk_sp<sksg::RenderNode  >> draws;

    const auto add_draw = [this, &draws](sk_sp<sksg::RenderNode> draw, const ShapeRec& rec) {

        // All draws can have an optional blend mode.

        draws.push_back(this->attachBlendMode(rec.fJson, std::move(draw)));

    };

    for (auto rec = recs.rbegin(); rec != recs.rend(); ++rec) {

        const AutoPropertyTracker apt(this, rec->fJson, PropertyObserver::NodeType::OTHER);

        switch (rec->fInfo.fShapeType) {

        case ShapeType::kGeometry: {

            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gGeometryAttachers));

            if (auto geo = gGeometryAttachers[rec->fInfo.fAttacherIndex](rec->fJson, this)) {

                geos.push_back(std::move(geo));

            }

        } break;

        case ShapeType::kGeometryEffect: {

            // Apply the current effect and pop from the stack.

            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gGeometryEffectAttachers));

            if (!geos.empty()) {

                geos = gGeometryEffectAttachers[rec->fInfo.fAttacherIndex](rec->fJson,

                                                                           this,

                                                                           std::move(geos));

            }

            SkASSERT(&ctx->fGeometryEffectStack->back().fJson == &rec->fJson);

            SkASSERT(ctx->fGeometryEffectStack->back().fAttach ==

                     gGeometryEffectAttachers[rec->fInfo.fAttacherIndex]);

            ctx->fGeometryEffectStack->pop_back();

        } break;

        case ShapeType::kGroup: {

            AttachShapeContext groupShapeCtx(&geos,

                                             ctx->fGeometryEffectStack,

                                             ctx->fCommittedAnimators);

            if (auto subgroup =

                this->attachShape(rec->fJson["it"], &groupShapeCtx, rec->fSuppressed)) {

                add_draw(std::move(subgroup), *rec);

                SkASSERT(groupShapeCtx.fCommittedAnimators >= ctx->fCommittedAnimators);

                ctx->fCommittedAnimators = groupShapeCtx.fCommittedAnimators;

            }

        } break;

        case ShapeType::kPaint: {

            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gPaintAttachers));

            auto paint = gPaintAttachers[rec->fInfo.fAttacherIndex](rec->fJson, this);

            if (!paint || geos.empty() || rec->fSuppressed)

                break;

            auto drawGeos = geos;

            // Apply all pending effects from the stack.

            for (auto it = ctx->fGeometryEffectStack->rbegin();

                 it != ctx->fGeometryEffectStack->rend(); ++it) {

                drawGeos = it->fAttach(it->fJson, this, std::move(drawGeos));

            }

            // Apply local paint geometry adjustments (e.g. dashing).

            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gPaintGeometryAdjusters));

            if (const auto adjuster = gPaintGeometryAdjusters[rec->fInfo.fAttacherIndex]) {

                drawGeos = adjuster(rec->fJson, this, std::move(drawGeos));

            }

            // If we still have multiple geos, reduce using 'merge'.

            auto geo = drawGeos.size() > 1

                ? ShapeBuilder::MergeGeometry(std::move(drawGeos), sksg::Merge::Mode::kMerge)

                : drawGeos[0];

            SkASSERT(geo);

            add_draw(sksg::Draw::Make(std::move(geo), std::move(paint)), *rec);

            ctx->fCommittedAnimators = fCurrentAnimatorScope->size();

        } break;

        case ShapeType::kDrawEffect: {

            SkASSERT(rec->fInfo.fAttacherIndex < SK_ARRAY_COUNT(gDrawEffectAttachers));

            if (!draws.empty()) {

                draws = gDrawEffectAttachers[rec->fInfo.fAttacherIndex](rec->fJson,

                                                                        this,

                                                                        std::move(draws));

                ctx->fCommittedAnimators = fCurrentAnimatorScope->size();

            }

        } break;

        default:

            break;

        }

    }

    // By now we should have popped all local geometry effects.

    SkASSERT(ctx->fGeometryEffectStack->size() == initialGeometryEffects);

    sk_sp<sksg::RenderNode> shape_wrapper;

    if (draws.size() == 1) {

        // For a single draw, we don't need a group.

        shape_wrapper = std::move(draws.front());

    } else if (!draws.empty()) {

        // Emit local draws reversed (bottom->top, per spec).

        std::reverse(draws.begin(), draws.end());

        draws.shrink_to_fit();

        // We need a group to dispatch multiple draws.

        shape_wrapper = sksg::Group::Make(std::move(draws));

    }

    sk_sp<sksg::Transform> shape_transform;

    if (jtransform) {

        const AutoPropertyTracker apt(this, *jtransform, PropertyObserver::NodeType::OTHER);

        // This is tricky due to the interaction with ctx->fCommittedAnimators: we want any

        // animators related to tranform/opacity to be committed => they must be inserted in front

        // of the dangling/uncommitted ones.

        AutoScope ascope(this);

        if ((shape_transform = this->attachMatrix2D(*jtransform, nullptr))) {

            shape_wrapper = sksg::TransformEffect::Make(std::move(shape_wrapper), shape_transform);

        }

        shape_wrapper = this->attachOpacity(*jtransform, std::move(shape_wrapper));

        auto local_scope = ascope.release();

        fCurrentAnimatorScope->insert(fCurrentAnimatorScope->begin() + ctx->fCommittedAnimators,

                                      std::make_move_iterator(local_scope.begin()),

                                      std::make_move_iterator(local_scope.end()));

        ctx->fCommittedAnimators += local_scope.size();

    }

    // Push transformed local geometries to parent list, for subsequent paints.

    for (auto& geo : geos) {

        ctx->fGeometryStack->push_back(shape_transform

            ? sksg::GeometryTransform::Make(std::move(geo), shape_transform)

            : std::move(geo));

    }

    return shape_wrapper;

}

sk_sp<sksg::RenderNode> AnimationBuilder::attachShapeLayer(const skjson::ObjectValue& layer,

                                                           LayerInfo*) const {

    std::vector<sk_sp<sksg::GeometryNode>> geometryStack;

    std::vector<GeometryEffectRec> geometryEffectStack;

    AttachShapeContext shapeCtx(&geometryStack, &geometryEffectStack,

                                fCurrentAnimatorScope->size());

    auto shapeNode = this->attachShape(layer["shapes"], &shapeCtx);

    // Trim uncommitted animators: AttachShape consumes effects on the fly, and greedily attaches

    // geometries => at the end, we can end up with unused geometries, which are nevertheless alive

    // due to attached animators.  To avoid this, we track committed animators and discard the

    // orphans here.

    SkASSERT(shapeCtx.fCommittedAnimators <= fCurrentAnimatorScope->size());

    fCurrentAnimatorScope->resize(shapeCtx.fCommittedAnimators);

    return shapeNode;

}

} // namespace internal

} // namespace skottie