/*

 * Copyright 2022 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#ifndef SkottieFont_DEFINED

#define SkottieFont_DEFINED

#include "include/core/SkRefCnt.h"

#include "include/core/SkTypes.h"

#include "include/private/base/SkNoncopyable.h"

#include "include/utils/SkCustomTypeface.h"

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

#include "src/core/SkTHash.h"

#include <memory>

#include <utility>

#include <vector>

class SkPath;

class SkTypeface;

struct SkSize;

namespace skjson { class ObjectValue; }

namespace skottie::internal {

class AnimationBuilder;

// Font backed by Lottie character data (glyph paths and glyph compositions).

class CustomFont final : SkNoncopyable {

public:

    ~CustomFont();

    using GlyphCompMap = skia_private::THashMap<SkGlyphID, sk_sp<sksg::RenderNode>>;

    class Builder final : SkNoncopyable {

    public:

        bool parseGlyph(const AnimationBuilder*, const skjson::ObjectValue&);

        std::unique_ptr<CustomFont> detach();

    private:

        static bool ParseGlyphPath(const AnimationBuilder*, const skjson::ObjectValue&, SkPath*);

        static sk_sp<sksg::RenderNode> ParseGlyphComp(const AnimationBuilder*,

                                                      const skjson::ObjectValue&,

                                                      SkSize*);

        GlyphCompMap            fGlyphComps;

        SkCustomTypefaceBuilder fCustomBuilder;

    };

    // Helper for resolving (SkTypeface, SkGlyphID) tuples to a composition root.

    // Used post-shaping, to substitute composition glyphs in the rendering tree.

    class GlyphCompMapper final : public SkRefCnt {

    public:

        explicit GlyphCompMapper(std::vector<std::unique_ptr<CustomFont>>&& fonts)

            : fFonts(std::move(fonts)) {}

        ~GlyphCompMapper() override = default;

        sk_sp<sksg::RenderNode> getGlyphComp(const SkTypeface*, SkGlyphID) const;

    private:

        const std::vector<std::unique_ptr<CustomFont>> fFonts;

    };

    const sk_sp<SkTypeface>& typeface() const { return fTypeface; }

    int glyphCompCount() const { return fGlyphComps.count(); }

private:

    CustomFont(GlyphCompMap&&, sk_sp<SkTypeface> tf);

    const GlyphCompMap      fGlyphComps;

    const sk_sp<SkTypeface> fTypeface;

};

}  // namespace skottie::internal

#endif  // SkottieFont_DEFINED