/*

 * Copyright 2021 Google LLC

 *

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

 * found in the LICENSE file.

 */

#ifndef MSKPPlayer_DEFINED

#define MSKPPlayer_DEFINED

#include "include/core/SkRefCnt.h"

#include "include/core/SkSize.h"

#include <memory>

#include <unordered_map>

#include <vector>

class SkCanvas;

class SkImage;

class SkStreamSeekable;

class SkSurface;

/**

 * Plays frames/pages of a MSKP to a canvas. This class uses the term "frame" as though the MSKP

 * contains an animation, though it could indeed contain pages of a static document.

 */

class MSKPPlayer {

public:

    ~MSKPPlayer();

    /** Make a player from a MSKP stream, or null if stream can't be read as MSKP. */

    static std::unique_ptr<MSKPPlayer> Make(SkStreamSeekable* stream);

    /** Maximum width and height across all frames. */

    SkISize maxDimensions() const { return fMaxDimensions; }

    /** Total number of frames. */

    int numFrames() const { return static_cast<int>(fRootLayers.size()); }

    /** Size of an individual frame. */

    SkISize frameDimensions(int i) const;

    /**

     * Plays a frame into the passed canvas. Frames can be randomly accessed. Offscreen layers are

     * incrementally updated from their current state to the state required for the frame

     * (redrawing from scratch if their current state is ahead of the passed frame index).

     */

    bool playFrame(SkCanvas* canvas, int i);

    /** Destroys any cached offscreen layers. */

    void resetLayers();

    /**

     * Forces all offscreen layers to re-render the next time they're required for a frame but

     * preserves the backing stores for them if already allocated.

     */

    void rewindLayers();

    /**

     * Creates backing stores for any offscreen layers using the passed canvas's makeSurface().

     * Existing layers that match the canvas's recording context are not reallocated or rewound.

     */

    void allocateLayers(SkCanvas*);

    /**

     * A set of IDs of offscreen layers in no particular order. If frame value >= 0 is specified

     * then the layer set is filtered to layers used by that frame (or empty if >= numFrames). If

     * < 0 then gathers all the layers across all frames.

     */

    std::vector<int> layerIDs(int frame = -1) const;

    /**

     * Gets the contents of an offscreen layer. It's contents will depend on current playback state

     * (playFrame(), updateFrameLayers(), resetLayers()). If the layer currently has no backing

     * store because it hasn't been drawn or resetLayers() was called then this will return nullptr.

     * Layer contents are not affected by rewindLayers() as that simply lazily redraws the frame

     * contents the next time it is required by playFrame*() or updateFrameLayers().

     */

    sk_sp<SkImage> layerSnapshot(int layerID) const;

private:

    MSKPPlayer() = default;

    // noncopyable, nonmoveable.

    MSKPPlayer(const MSKPPlayer&) = delete;

    MSKPPlayer(MSKPPlayer&&) = delete;

    MSKPPlayer& operator=(const MSKPPlayer&) = delete;

    MSKPPlayer& operator=(MSKPPlayer&&) = delete;

    // Cmds are used to draw content to the frame root layer and to offscreen layers.

    struct Cmd;

    // Draws a SkPicture.

    struct PicCmd;

    // Draws another layer. Stores the ID of the layer to draw and what command index on that

    // layer should be current when the layer is drawn. The layer contents are updated to the

    // stored command index before the layer is drawn.

    struct DrawLayerCmd;

    // The commands for a root/offscreen layer and dimensions of the layer.

    struct LayerCmds {

        LayerCmds() = default;

        LayerCmds(LayerCmds&&) = default;

        SkISize fDimensions;

        std::vector<std::unique_ptr<Cmd>> fCmds;

    };

    // Playback state of layer: the last command index drawn to it and the SkSurface with contents.

    struct LayerState {

        size_t fCurrCmd = -1;

        sk_sp<SkSurface> fSurface;

    };

    static sk_sp<SkSurface> MakeSurfaceForLayer(const LayerCmds&, SkCanvas* rootCanvas);

    void collectReferencedLayers(const LayerCmds& layer, std::vector<int>*) const;

    // MSKP layer ID -> LayerCmds

    using LayerMap = std::unordered_map<int, LayerCmds>;

    // MSKP layer ID -> LayerState

    using LayerStateMap = std::unordered_map<int, LayerState>;

    /**

     * A SkCanvas that consumes the SkPicture and records Cmds into a Layer. It will spawn

     * additional Layers and record nested SkPictures into those using additional CmdRecordCanvas

     * CmdRecordCanvas instances. It needs access to fOffscreenLayers to create and update LayerCmds

     * structs for offscreen layers.

     */

    class CmdRecordCanvas;

    SkISize            fMaxDimensions = {0, 0};  // Max dimensions across all frames.

    LayerMap           fOffscreenLayers;         // All the offscreen layers for all frames.

    LayerStateMap      fOffscreenLayerStates;    // Current surfaces and command idx for offscreen

                                                 // layers

    std::vector<LayerCmds> fRootLayers;          // One root layer for each frame.

};

#endif