#pragma once

#ifndef TRENDERER_INCLUDED
#define TRENDERER_INCLUDED

#include "trasterfx.h"

#undef DVAPI
#undef DVVAR
#ifdef TFX_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

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

//  Forward declarations

class TRenderer;
class TRendererImp;
class TException;
class TRenderSettings;
class TRasterFxP;
class TFxCacheManager;
class TRenderResourceManager;
class TRenderResourceManagerGenerator;

class TFxPair {
public:
  TRasterFxP m_frameA, m_frameB;
  TFxPair() : m_frameA(), m_frameB() {}
  TFxPair(const TRasterFxP &frameA, TRasterFxP &frameB)
      : m_frameA(frameA), m_frameB(frameB) {}
};

// typedef std::pair<TRasterFxP, TRasterFxP> TFxPair;

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

//====================
//    TRenderPort
//--------------------

//! The TRenderPort class acts as a spatially-declared listener to a TRenderer
//! instance.
//! TRenderPorts are the formally supported receivers of TRenderer's activity
//! notifications;
//! they provide some basic pure virtual members that are appropriately invoked
//! by the TRenderer
//! when an associated interesting render event takes place.

class DVAPI TRenderPort {
  TRectD m_renderArea;

public:
  struct RenderData;

  TRenderPort();
  virtual ~TRenderPort();

  void setRenderArea(const TRectD &area);
  TRectD &getRenderArea();

  virtual void onRenderRasterStarted(const RenderData &renderData) {}
  virtual void onRenderRasterCompleted(const RenderData &renderData) {}
  virtual void onRenderFailure(const RenderData &renderData, TException &e) {}
  virtual void onRenderFinished(bool isCanceled = false) {}
};

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

//================================
//    TRenderPort::RenderData
//--------------------------------

//! This storage struct contains the elementary data necessary to identify a
//! cluster of identical
//! rendered frames from TRenderer. In order to avoid recalculation of identical
//! frames during a
//! render process, they are merged in one 'equivalence cluster' of which only
//! one representant is
//! rendered; the m_frames member stores each frame of such cluster. The
//! associated raster is stored
//! in the m_ras member. Additional returned infos include the TRenderSettings
//! under which the frames
//! were rendered, and unique identification vars.

struct TRenderPort::RenderData {
  std::vector<double> m_frames;  //!< Frames this output represents
  TRenderSettings m_info;        //!< Output settings description
  TRasterP m_rasA, m_rasB;  //!< The output images; m_rasB is not empty only for
                            //! interlacacing and stereoscopic.
  unsigned long m_renderId;  //!< Identifier of the rendering session this
                             //! output belongs to
  unsigned long m_taskId;  //!< Task identifier in the rendering session. Starts
                           //! at 0, preserves
  //!< the original submission order except for cluster equivalence.

  RenderData() : m_renderId((unsigned long)-1), m_taskId((unsigned long)-1) {}
  RenderData(const std::vector<double> &frames, const TRenderSettings &info,
             const TRasterP &rasA, const TRasterP &rasB, unsigned long renderId,
             unsigned long taskId)
      : m_frames(frames)
      , m_info(info)
      , m_rasA(rasA)
      , m_rasB(rasB)
      , m_renderId(renderId)
      , m_taskId(taskId) {}
};

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

//=========================================================
//
//    TRenderer
//
//---------------------------------------------------------

//! The TRenderer class provides the core operative interface to the Toonz
//! rendering library.

//! The TRenderer's main purpose is that of invoking a render process on a group
//! of separate threads through the \b startRendering() methods. After this is
//! done,
//! the activated process communicates with any TRenderPort previously set
//! through
//! the \b addPort() method in order to notify the render status.
//! The rendering process can be interrupted with the stopRendering() method,
//! which
//! makes all rendering threads quit safely at the most appropriate time; the
//! more
//! specific abortRendering() method may be used to terminate a render process
//! id in case
//! more than one process is running.
//! \n \n
//! Technically, this class is an \a interface to the actual rendering class,
//! which remains in background. This means that users have no necessity of
//! maintaining the
//! TRenderer instance alive as a render process is running. We may, for
//! example,
//! create a TRenderer, set its properties, launch the render, and release the
//! TRenderer
//! instance immediately after as the internal rendering class will continue
//! working on.
//! TRenderers may therefore be copied and assigned freely to refer an already
//! existing
//! internal rendering instance. These are created anew only using the default
//! TRenderer(int) constructor.
//! \n \n
//! On the other hand, TRenderer's lifespan may last longer than that of a
//! single rendering
//! process. This is especially useful when it is known that multiple rendering
//! processes share
//! some common resources (likewise, intermediate cache results), which can be
//! maintained
//! in the same internal TRenderer representation for later use.
//! \n \n
//! Some final notes about methods dealing with Toonz's lower-level API. Direct
//! invocation
//! of rendering functions, such as the TRasterFx::compute() method, is
//! discouraged. Further
//! improvements of the TRenderer's API will eventually make the need for these
//! calls obsolete. However,
//! we've implemented the possibilty to rely on TRenderer's management support
//! even in those cases -
//! it can be done by declaring the render process' interesting events through
//! the apposite <a> declare..() <\a>
//! methods and invoking install() and uninstall() on each rendering thread
//! you'll raise
//! for the process.

class DVAPI TRenderer {
  TRendererImp *m_imp;

  friend class TRenderResourceManagerGenerator;
  TRenderResourceManager *getManager(unsigned int id) const;

public:
  //! The RenderData struct contains the frame specifics to supply for a
  //! TRenderer::startRendering() call.
  struct RenderData {
    double m_frame;
    TRenderSettings m_info;
    TFxPair m_fxRoot;  // The second of pair is used for field interlacing or
                       // stereoscopic render.

    RenderData(double frame, const TRenderSettings &info, const TFxPair &fxRoot)
        : m_frame(frame), m_info(info), m_fxRoot(fxRoot) {}
  };

public:
  TRenderer(int nThread = 1);
  TRenderer(TRendererImp *);
  ~TRenderer();

  TRenderer(const TRenderer &);
  void operator=(const TRenderer &);

  operator bool() const { return m_imp; }

  void addPort(TRenderPort *port);
  void removePort(TRenderPort *port);

  unsigned long startRendering(
      const std::vector<TRenderer::RenderData> *renderDatas);
  unsigned long startRendering(double f, const TRenderSettings &info,
                               const TFxPair &actualRoot);

  void abortRendering(unsigned long renderId);
  void stopRendering(bool waitForCompleteStop = false);

  void enablePrecomputing(bool on);
  bool isPrecomputingEnabled() const;

  void setThreadsCount(int nThreads);

  static TRenderer instance();

  unsigned long rendererId();
  static unsigned long renderId();
  static unsigned long nextRenderId();

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

  // Render instance properties

  enum RenderStatus {
    IDLE      = 0x0,
    FIRSTRUN  = 0x1,
    TESTRUN   = 0x2,
    COMPUTING = 0x4
  };
  int getRenderStatus(unsigned long renderId) const;
  bool isAborted(unsigned long renderId) const;

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

  //  To install the TRenderer on lower-level rendering invocations
  static unsigned long buildRenderId();

  void declareRenderStart(unsigned long renderId);
  void declareRenderEnd(unsigned long renderId);

  void declareFrameStart(double frame);
  void declareFrameEnd(double frame);

  void install(unsigned long renderId);
  void uninstall();

  // Be sure that this method is called at least once before a rendering driven
  // by a working thread
  // (the TRendererStartInvoker singleton must be referred first by a thread
  // that survives, e.g. the main thread)
  static void initialize();
};

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

typedef std::vector<TRenderer::RenderData> RenderDataVector;

#endif