#pragma once

#ifndef TFXCACHEMANAGER_H

#define TFXCACHEMANAGER_H

#include <memory></memory>

#include "trenderresourcemanager.h"

#include "tcacheresource.h"

//=======================================================================

//  Forward declarations

struct ResourceDeclaration;

typedef std::pair<resourcedeclaration *,="" tcacheresourcep=""> ResourceData;</resourcedeclaration>

class TFxCacheManager;

class TFxCacheManagerDelegate;

// class TFxCacheManagerListener;

//=======================================================================

//=====================================

//    ResourceBuilder class

//-------------------------------------

/*!

The ResourceBuilder class is the preferential base interface that must be used

to

by eventual users to interact with the Toonz cache during render processes.

Caching can be used to specify that some intermediate rendering result is

useful,

and efforts should be taken to ensure that it is stored in memory rather than

repeatedly rebuilt, when it is sufficiently convenient.

\n

These kind of operations are automatically performed by Toonz on the overall

results of

fx nodes - users should definitely implement hidden fx nodes rather than a

specialized

ResourceBuilder class. However, ResourceBuilder provides a more simple and

generic API

than TRasterFx's, and does not force code splitting into several fxs.

This class already works out most of the implementation details necessary

to deal with cache management and predictability issues.

\n \n

It just requires the implementation of two essential functions:

 The compute() method, which performs the effective calculation of the

passed tile.

 The simCompute() method, which is a dummy simulation of the above

compute(),

used by the builder for predictive purposes.

Please refer to their descriptions for implementation details.

\n \n

Once the necessary compute() and simCompute() functions have been supplied, the

ResourceBuilder can be used to obtain the resource data associated with passed

TTile

simply by invoking the build() method. The build() invocation performs all the

cache resource availability checkings, retrieval, and the eventual resource

calculation

on its own.

\n \n

The simBuild() method is the dummy counterpart for build(), which must be used

in the

simCompute() simulations whenever some father resource requires that a child

resource

is built first.

*/

class DVAPI ResourceBuilder {

  TFxCacheManager *m_cacheManager;

  ResourceData m_data;

protected:

  virtual void simCompute(const TRectD &rect) = 0;

  virtual void compute(const TRectD &rect)    = 0;

  virtual void upload(TCacheResourceP &resource)   = 0;

  virtual bool download(TCacheResourceP &resource) = 0;

public:

  ResourceBuilder(const std::string &resourceName, const TFxP &fx, double frame,

                  const TRenderSettings &rs);

  virtual ~ResourceBuilder() {}

  static void declareResource(const std::string &alias, const TFxP &fx,

                              const TRectD &rect, double frame,

                              const TRenderSettings &rs,

                              bool subtileable = true);

  void simBuild(const TRectD &tile);

  void build(const TRectD &tile);

};

//************************************************************************************************

//    Cache Management internals

//************************************************************************************************

//! The ResourceDeclaration structure contains the informations retrieved in the

//! predictive processes performed before a render process. It can be retrieved

//! via the TFxCacheManager::getResource() method or passed directly by it to

//! TFxCacheManagerDelegate instances.

struct ResourceDeclaration {

  //! ResourceDeclaration's Raw data is gathered in the first predictive run for

  //! a render process. It is destroyed before the actual process begins due to

  //! its considerable size.

  struct RawData {

    // Requested infos for calculation

    //! Fx who generated the data

    TFxP m_fx;

    //! Frame at which the data was generated

    double m_frame;

    //! Render settings associated with the data

    TRenderSettings m_rs;

    //! Tiles declared in the prediction process.

    //! May differ from those actually calculated by the renderer.

    std::vector<trectd> m_tiles;</trectd>

    // Useful infos

    //! Bounding box associated with the considered fx calculation

    // TRectD m_bbox;

    //! Whether the resource may be subdivided for calculation

    bool m_subtileable;

  };

  //! The ResourceDeclaration's Raw data is processed into a vector of

  //! TileDatas, representing the actual tiles to be computed in the render

  //! process.

  struct TileData {

    TRectD m_rect;

    int m_refCount;

    bool m_calculated;

    TileData(const TRectD &rect)

        : m_rect(rect), m_refCount(0), m_calculated(false) {}

  };

public:

  RawData *m_rawData;

  std::vector<tiledata> m_tiles;</tiledata>

  int m_tilesCount;

  ResourceDeclaration() : m_rawData(0), m_tilesCount(0) {}

  ~ResourceDeclaration() {}

};

//=======================================================================

typedef std::pair<resourcedeclaration *,="" tcacheresourcep=""> ResourceData;</resourcedeclaration>

//=======================================================================

//======================

//    Cache Manager

//----------------------

/*!

The TFxCacheManager is the main resource manager that deals with fx nodes

caching

inside Toonz rendering processes. During a render process, a considerable amount

of time

can be saved if any intermediate rendered result used more than once is saved in

cache

and reused multiple times rather than rebuilding it every time. In some cases,

the user may even

know that some specific intermediate result is useful for rendering purposes,

and could

explicitly require that it needs to be cached.

\n \n

In Toonz's rendering workflow, these operations are managed by the

TFxCacheManager class,

which delegates specific caching procedures to a group of

TFxCacheManagerDelegate instances.

\n \n

Access to a cache resource is performed through the getResource() method, which

requires

a description of the resource (as specified in the TCacheResource class)

and some informations - namely, the fx, render settings and frame - about the

circumstances

of the request. If the resource is managed by some manager delegate, it will be

returned.

\n \n

Resource uploads and downloads must be notified through the apposite methods to

inform the

manager delegates appropriately. These notifications can be invoked without need

that

the associated method is actually invoked for the resource - this is especially

required

when the TRenderer instance is simulating the actual render process for

predictive purposes.

\sa TCacheResource, TPassiveCacheManager, TPredictiveCacheManager and TRenderer

classes

*/

class DVAPI TFxCacheManager final : public TRenderResourceManager {

  T_RENDER_RESOURCE_MANAGER

private:

  // std::set<tfxcachemanagerlistener*> m_listeners;</tfxcachemanagerlistener*>

  std::set<tfxcachemanagerdelegate *=""> m_delegates;</tfxcachemanagerdelegate>

  std::set<std::string> m_staticCacheIds;</std::string>

  class Imp;

  std::unique_ptr<imp> m_imp;</imp>

public:

  TFxCacheManager();

  ~TFxCacheManager();

  static TFxCacheManager *instance();

  void add(const std::string &cacheId, TImageP img);

  void remove(const std::string &cacheId);

  void onRenderStatusStart(int renderStatus) override;

  void onRenderStatusEnd(int renderStatus) override;

  // void install(TFxCacheManagerListener* listener);

  // void uninstall(TFxCacheManagerListener* listener);

private:

  friend class ResourceBuilder;

  void declareResource(const std::string &alias, const TFxP &fx,

                       const TRectD &rect, double frame,

                       const TRenderSettings &rs, bool subtileable);

  ResourceData getResource(const std::string &resourceName, const TFxP &fx,

                           double frame, const TRenderSettings &rs);

  /*void notifyResourceUpload(const TCacheResourceP& resource, const TRect&

rect);

void notifyResourceDownload(const TCacheResourceP& resource, const TRect& rect);

void notifyPredictedRelease(const TCacheResourceP& resource);*/

private:

  friend class TFxCacheManagerDelegate;

  void install(TFxCacheManagerDelegate *managerDelegate);

};

//=======================================================================

//===============================

//    Cache Manager Delegate

//-------------------------------

/*!

TFxCacheManagerDelegate is the base class to implement cache managers used

in Toonz render processes.

A TFxCacheManagerDelegate instance automatically receives access notifications

through the TFxCacheManager associated with a render process.

These may either concern a request of a certain cache resource, or the storage

proposal of a calculated node result.

\warning Delegates are expected to be dependent on TFxCacheManager - use the

MANAGER_FILESCOPE_DECLARATION_DEP macro to achieve that.

\sa TCacheResource and TFxCacheManager classes

*/

class TFxCacheManagerDelegate : public TRenderResourceManager {

public:

  TFxCacheManagerDelegate() {}

  virtual void getResource(TCacheResourceP &resource, const std::string &alias,

                           const TFxP &fx, double frame,

                           const TRenderSettings &rs,

                           ResourceDeclaration *resData) = 0;

  void onRenderInstanceStart(unsigned long renderId) override {

    assert(TFxCacheManager::instance());

    TFxCacheManager::instance()->install(this);

  }

};

//=======================================================================

//===============================

//    Cache Manager Listener

//-------------------------------

/*class TFxCacheManagerListener

{

public:

  TFxCacheManagerListener() {}

  virtual void onResourceUpload(const TCacheResourceP& resource, const TRect&

rect) {}

  virtual void onResourceDownload(const TCacheResourceP& resource, const TRect&

rect) {}

  virtual void onPredictedRelease(const TCacheResourceP& resource) {}

};*/

#endif  // TFXCACHEMANAGER_H