#pragma once

#ifndef TCOLORSTYLES_H

#define TCOLORSTYLES_H

// TnzCore includes

#include "tfilepath.h"

#include "traster.h"

// Qt includes

#include <qstring></qstring>

#undef DVAPI

#undef DVVAR

#ifdef TVRENDER_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 TStroke;

class TRegion;

class TStrokeProp;

class TRegionProp;

class TVectorRenderData;

class TInputStreamInterface;

class TOutputStreamInterface;

class TRasterStyleFx;

class QStringList;

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

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

//    TRasterStyleFx  definition

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

class DVAPI TRasterStyleFx {

public:

  struct Params {

    TRasterP m_r;

    TPoint m_p;

    TRasterP m_rOrig;

    int m_colorIndex;

    int m_frame;

  public:

    Params(const TRasterP &r, const TPoint &p, const TRasterP &rOrig, int index,

           int frame)

        : m_r(r), m_p(p), m_rOrig(rOrig), m_colorIndex(index), m_frame(frame) {

      assert(m_r);

    }

  };

public:

  virtual ~TRasterStyleFx() {}

  virtual bool isInkStyle() const   = 0;

  virtual bool isPaintStyle() const = 0;

  virtual bool inkFxNeedRGBMRaster() const { return false; }

  virtual bool compute(const Params ¶ms) const = 0;

  virtual void getEnlargement(int &borderIn, int &borderOut) const {

    borderIn = borderOut = 0;

  }

};

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

//    TColorStyle  definition

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

/*!

  \brief Abstract class representing a color style in a Toonz palette.

*/

class DVAPI TColorStyle : public TSmartObject {

public:

  //! Helper class to declare color styles

  class Declaration {

  public:

    Declaration(TColorStyle *style) { declare(style); }

  };

  enum ParamType {

    BOOL,     //!< Boolean parameter type.

    INT,      //!< Integer parameter type.

    ENUM,     //!< Enum parameter type (maps to integer values).

    DOUBLE,   //!< Double parameter type (getParamType() default).

    FILEPATH  //!< TFilePath parameter type.

  };

  struct double_tag {};

  struct bool_tag {};

  struct int_tag {};

  struct TFilePath_tag {};

  struct PickedPosition {

    TPoint pos = TPoint();

    int frame  = 0;

    PickedPosition(TPoint _pos = TPoint(), int _frame = 0)

        : pos(_pos), frame(_frame) {}

    inline bool operator==(const PickedPosition &p) const {

      return (this->pos == p.pos) && (this->frame == p.frame);

    }

    inline bool operator!=(const PickedPosition &p) const {

      return (this->pos != p.pos) || (this->frame != p.frame);

    }

  };

private:

  std::wstring m_name;          //!< User-define style name.

  std::wstring m_globalName;    //!< User-define style \a global name.

  std::wstring m_originalName;  //!< If the style is copied from studio palette,

                                //! its original name is stored

  int m_versionNumber;  //!< Style's version number.

  unsigned int m_flags;  //!< Style attributes.

  bool m_enabled;        //!< Style's \a enabled status.

  bool m_isEditedFromOriginal;  //

                                // This flag will be set when the

  //!  style is edited from the original one.

  PickedPosition

      m_pickedPosition;  // picked position from color model by using style

                         // picker tool with "organize palette" option.

  std::size_t m_hash;  //!< Hash value for quick comparison.

protected:

  TRaster32P m_icon;  //!< Icon shown on TPalette viewers.

  bool m_validIcon;   //!< Icon's validity status.

public:

  static int m_currentFrame;  //!< Time instant in the palette's timeline.

                              //!  \deprecated  Should be done better

public:

  TColorStyle();

  TColorStyle(

      const TColorStyle &other);  //!< Copies another style \a except its icon

  virtual ~TColorStyle();

  virtual TColorStyle *clone() const = 0;  //!< Polymorphic clone of the style.

  virtual TColorStyle *clone(std::string brushIdName) const { return clone(); }

  virtual TColorStyle ©(

      const TColorStyle &other)  //!< Polymorphic copy of the style.

  {

    assignBlend(other, other, 0.0);

    return *this;

  }

  bool operator==(const TColorStyle &cs) const;

  bool operator!=(const TColorStyle &cs) { return !operator==(cs); }

  // Renderizer-related  objects

  virtual TStrokeProp *makeStrokeProp(

      const TStroke

          *stroke) = 0;  //!< Allocates a \a new derived TStrokeProp instance

  //!  used to draw the style on the specified stroke object.

  virtual TRegionProp *makeRegionProp(

      const TRegion

          *region) = 0;  //!< Allocates a \a new derived TRegionProp instance

  //!  used to draw the style on the specified region object.

  virtual bool isRasterStyle() const {

    return false;

  }  //!< Returns whether the style is of the raster kind.

  virtual TRasterStyleFx *getRasterStyleFx() {

    return 0;

  }  //!< If the style contains raster effects it must return it,

     //!  else returns 0.

  virtual bool isRegionStyle()

      const = 0;  //!< Returns whether the style applies on regions.

  virtual bool isStrokeStyle()

      const = 0;  //!< Returns whether the style applies on strokes.

  // General functions

  void setName(std::wstring name) {

    m_name = name;

  }  //!< Sets the style's user-defined name.

  std::wstring getName() const {

    return m_name;

  }  //!< Returns the style's user-defined name.

  /*! \detail

The \a global name contains information about palette id.

*/

  void setGlobalName(std::wstring name) {

    m_globalName = name;

  }  //!< Sets the global name of the style.

  std::wstring getGlobalName() const {

    return m_globalName;

  }  //!< Returns the global name of the style.

  void setOriginalName(std::wstring name) {

    m_originalName = name;

  }  //!< If the style is originally copied from studio palette, set this.

  std::wstring getOriginalName() const {

    return m_originalName;

  }  //!< Returns the original name of the style.

  void setIsEditedFlag(bool edited) {

    m_isEditedFromOriginal = edited;

  }  //

     // the

  //!  style is edited from the original one.

  bool getIsEditedFlag() const {

    return m_isEditedFromOriginal;

  }  //!< Returns whether the style is edited from the original from studio

     //! palette

  void assignNames(

      const TColorStyle *src);  //!< Copies the style names from src.

  //! \sa tcolorflags.h

  unsigned int getFlags() const { return m_flags; }  //!< Sets color attributes.

  void setFlags(unsigned int flags) {

    m_flags = flags;

  }  //!< Returns color attributes.

  void setPickedPosition(const TPoint &pos, const int index = 0) {

    m_pickedPosition.pos   = pos;

    m_pickedPosition.frame = index;

  }

  void setPickedPosition(const PickedPosition &pos) { m_pickedPosition = pos; }

  PickedPosition getPickedPosition() const { return m_pickedPosition; }

  // Color-related functions

  /*! \detail

Raster or vector pattern image styles, for example, return false.

*/

  virtual bool hasMainColor() const {

    return false;

  }  //!< Returns whether the style has a reference \a main color.

  virtual TPixel32 getMainColor() const {

    return TPixel32::Black;

  }  //!< Returns the style's main color, or black if none.

  virtual void setMainColor(const TPixel32 &color) {

  }  //!< Sets the main color, if it has one.

  /*! \detail

For example a bubble styles has two colors.

By default it returns \p 1 if the style has only a main color else

returns \p 0 if the style has no color.

*/

  virtual int getColorParamCount() const {

    return hasMainColor() ? 1 : 0;

  }  //!< Returns the number of colors (if any) of the style.

  /*! \detail

Returns the main color by default.

*/

  virtual TPixel32 getColorParamValue(int index) const {

    return getMainColor();

  }  //!< Returns the value of the color of index \e index.

  virtual void setColorParamValue(int index, const TPixel32 &color) {

    setMainColor(color);

  }  //!< Sets the \a index-th color value.

  virtual TPixel32 getAverageColor() const {

    return getMainColor();

  }  //!< Returns a color representing the average of all the style's colors

  // Parameters-related functions

  /*! \detail

   For example: a the general cleanup style has two parameters, brightness and

   contrast and

   a black cleanup style has in addition a black and white threshold, therefore

   4 parameters.

*/

  virtual int getParamCount() const {

    return 0;

  }  //!< Returns the number of parameters necessary

     //!  to describe the style.

  virtual ParamType getParamType(int paramIdx) const {

    assert(0 <= paramIdx && paramIdx < getParamCount());

    return DOUBLE;

  }  //!< Returns the type of the specified parameter.

  virtual bool hasParamDefault(int index) const {

    return false;

  }  //!< Value of parameter can be reset to default.

  virtual void setParamDefault(int index) {

    assert(false);

  }  //!< Reset value of parameter to default.

  virtual bool isParamDefault(int index) const {

    return false;

  }  //!< Check if current value of parameter equals to default

  virtual void setParamValue(int index, bool value) {

    assert(false);

  }  //!< Assigns a value to the specified \p bool parameter.

  virtual bool getParamValue(bool_tag, int index) const {

    assert(false);

    return bool();

  }  //!< Retrieves the specified \p bool parameter value.

  virtual void setParamValue(int index, int value) {

    assert(false);

  }  //!< Assigns a value to the specified \p int parameter.

  virtual int getParamValue(int_tag, int index) const {

    assert(false);

    return int();

  }  //!< Retrieves the specified \p int parameter value.

  virtual void getParamRange(int index, int &min, int &max) const {

    assert(false);

  }  //!< Retrieves the specified \p int parameter range.

  virtual void getParamRange(int pIndex, QStringList &stringItems) const {

    assert(false);

  }  //!< Returns a description of each supported enum or file

  //!  extension value in text form.

  virtual void setParamValue(int index, double value) {

    assert(false);

  }  //!< Assigns a value to the specified \p double parameter.

  virtual double getParamValue(double_tag, int index) const {

    assert(false);

    return double();

  }  //!< Retrieves the specified \p double parameter value.

  virtual void getParamRange(int index, double &min, double &max) const {

    assert(false);

  }  //!< Retrieves the specified \p double parameter range.

  virtual void setParamValue(int index, const TFilePath &fp) {

    assert(false);

  }  //!< Assigns a value to the specified \p TFilePath parameter.

  virtual TFilePath getParamValue(TFilePath_tag, int index) const {

    assert(false);

    return TFilePath();

  }  //!< Retrieves the specified \p TFilePath parameter value.

  /*! \detail

This function is provided to animate a palette style. Given two keyframe

styles \p a and \p b, it calculates their linear interpolation at parameter

\p t and assigns the result to this style instance.

\param a    Style value at parameter <tt>t = 0</tt>.

\param b    Style value at parameter <tt>t = 1</tt>.

\param t    Interpolation parameter.

*/

  void assignBlend(const TColorStyle &a, const TColorStyle &b,

                   double t);  //!< Assigns the linear interpolation between the

                               //!  supplied styles.

  // Description-related functions

  /*! \detail

For example for a stroke style we have "Constant", "Chain", "Rope", "Tulle",

etc...

*/

  virtual QString getDescription()

      const;  //!< Return a brief description of the style.

  virtual QString getParamNames(int index)

      const;  //!< Return the string that identifies the \a index-th parameter.

  virtual std::string getBrushIdName()

      const;  //!< Return a name identifying the brush.

  static std::size_t generateHash(std::string brushIdName);

  std::size_t getBrushIdHash();  //!< Hash for quick comparison (cached).

  static std::string getBrushIdNameClass(

      std::string brushIdName);  //!< Get class inside brush id name

  static std::string getBrushIdNameParam(

      std::string brushIdName);  //!< Get parameter inside brush id name

  // I/O-related  functions

  virtual int getTagId()

      const = 0;  //!< Returns an unique number representing the style.

  virtual void getObsoleteTagIds(std::vector<int> &) const {};  //!< \deprecated</int>

  void save(TOutputStreamInterface &) const;  //!< Calls the local

                                              //! implementation of saveData()

  //! passing it also the name and the tagId of the style.

  static TColorStyle *load(TInputStreamInterface &);  //!< Loads the style from

                                                      //! disk. Calls the local

  //! implementation of loadData().

  static TColorStyle *create(

      int tagId);  //!< Creates a new style with identifier equal to \a tagId.

  static TColorStyle *create(std::string brushIdName);

  static void declare(

      TColorStyle *style);  //!< Puts the style in the table of actual styles.

  static void getAllTags(std::vector<int> &tags);</int>

  // Misc functions

  /*! \detail

It is used when updates must be done after changes or creation of new styles.

*/

  void invalidateIcon() {

    m_validIcon = false;

  }  //!< Sets a flag that defines the style's icon validity.

  virtual const TRaster32P &getIcon(

      const TDimension &d);  //!< Returns an image representing the style.

  bool isEnabled() const {

    return m_enabled;

  }  //!< Returns whether the style can be used.

  void enable(bool on) {

    m_enabled = on;

  }  //!< Sets the style's \a enabled status

  int getVersionNumber() const {

    return m_versionNumber;

  }  //!< Returns the version number of the style.

  virtual TRectD getStrokeBBox(const TStroke *stroke) const;

protected:

  virtual void makeIcon(const TDimension &d);

  virtual void loadData(TInputStreamInterface &)        = 0;

  virtual void saveData(TOutputStreamInterface &) const = 0;

  virtual void loadData(int, TInputStreamInterface &) {

  }  //!< \deprecated  Backward compatibility

  void updateVersionNumber();

protected:

  TColorStyle &operator=(

      const TColorStyle &other);  //!< Copies another style \a except its icon

};

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

#ifdef _WIN32

template class DVAPI TSmartPointerT<tcolorstyle>;</tcolorstyle>

#endif

typedef TSmartPointerT<tcolorstyle> TColorStyleP;</tcolorstyle>

#endif  // TCOLORSTYLES_H