#pragma once

#ifndef TPALETTE_H

#define TPALETTE_H

// TnzCore includes

#include "tpersist.h"

#include "timage.h"

#include "tfilepath.h"

#include "tpixel.h"

#include "tcolorstyles.h"

// Qt includes

#include <qmutex></qmutex>

#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

#ifdef _WIN32

#pragma warning(push)

#pragma warning(disable : 4251)

#endif

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

//    Forward declarations

class TPixelRGBM32;

typedef TSmartPointerT<tpalette> TPaletteP;</tpalette>

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

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

//    TPalette  declaration

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

/*!

  \brief    The class representing a Toonz palette object.

  \par Rationale

    A palette is a collection of color styles that adds a level of indirection

    on color selections when drawing certain graphical objects.

\n

    Palette-based objects store style identifiers into an associated palette object,

    rather than the colors directly. When a color needs to be accessed, the palette

    objects is queried for a style id, and the associated \a style is returned.

\n

    A TColorStyle instance generalizes the notion of \a color, providing the ability to

    reduce a style instance to a color, \a and specialized drawing functions for

    vector graphics objects.

  \par Reserved colors

    A palette object has two fixed \a reserved styles - which cannot be removed - at

    indexes \p 0 and \p1. Index \p 0 is reserved for the \b transparent color. Index \p 1

    is reserved for the \b ink color, initialized by default to black.

  \par Syntax

    A palette is supposedly created on the heap, to the point that, in current

    implementation, copy and assignment are \a forbidden. This behavior is somewhat

    inconsitent since a palette \b is currently \a clonable and \a assignable with the

    appropriate functions. Normalization to common C++ syntax should be enforced ASAP.

\sa The TColorStyle class.

*/

class DVAPI TPalette : public TPersist, public TSmartObject

{

	DECLARE_CLASS_CODE

	PERSIST_DECLARATION(TPalette);

public:

	/*!

		\brief A palette page is a restricted view of a palette instance.

	*/

	class DVAPI Page

	{

		friend class TPalette;

	private:

		std::wstring m_name;			//!< Name of the page to be displayed.

		int m_index;			//!< Index of the page in the palette's pages collection.

		TPalette *m_palette;	//!< (\p not \p owned)  Palette the page refers to.

		std::vector<int> m_styleIds; //!< Palette style ids contained in the page.</int>

	public:

		Page(std::wstring name);

		std::wstring getName() const { return m_name; }	//!< Returns the name of the page.

		void setName(std::wstring name) { m_name = name; } //!< Sets the name of the page.

		TPalette *getPalette() const { return m_palette; } //!< Returns a pointer to the palette that contains this page.

		int getIndex() const { return m_index; } //!< Returns the page index in the palette.

		int getStyleCount() const { return (int)m_styleIds.size(); } //!< Returns the number of the styles contained in the page.

		int getStyleId(int indexInPage) const;		  //!< Returns the \a index-th style id in the page, or \p -1 if not found.

		TColorStyle *getStyle(int indexInPage) const; //!< Returns the \a index-th style in the page, or \p 0 if not found.

		//! \return The insertion index in the page, or \p -1 on failure

		int addStyle(int styleId); //!< Adds the specified style Id to the page (at the \a back

								   //!  of the page).

		/*!

      \warning  The supplied style must have been allocated with \a new.

      \warning  Style ownership is surrendered to the palette.

      \return   The insertion index in the page, or \p -1 on failure.

                In case of failure, the supplied style is \a deleted.

    */

		int addStyle(TColorStyle *style); //!< Adds the specified style to the palette, and assigns it

										  //!  to this page.

		//! \return The insertion index in the page, or \p -1 on failure

		int addStyle(TPixel32 color); //!< Add a solid color style to the palette, and assigns it

									  //!  to this page.

		void insertStyle(int indexInPage, int styleId); //!< Inserts the supplied style id at the specified position

														//!  in the page.

		//! \sa The specifics of addStyle(TColorStyle*) apply here.

		void insertStyle(int indexInPage, TColorStyle *style); //!< Inserts the supplied style in the palette, and assigns its

															   //!  id at the specified position in the page.

		void insertStyle(int indexInPage, TPixel32 color);	 //!< Inserts a solid color style in the palette, and assigns its

															   //!  id at the specified position in the page.

		void removeStyle(int indexInPage);	//!< Removes the style at the specified position from this page.

		int search(int styleId) const;		  //!< Returns the page position of the specified style id,

											  //!  or \p -1 if it cannot be found on the page.

		int search(TColorStyle *style) const; //!< Returns the page position of the specified style,

											  //!  or \p -1 if it cannot be found on the page.

	};

private:

	typedef std::map<int, tcolorstylep=""> StyleAnimation;		   //!< Style keyframes list.</int,>

	typedef std::map<int, styleanimation=""> StyleAnimationTable; //!< Style keyframes list per style id.</int,>

	friend class Page;

private:

	std::wstring m_globalName;  //!< Palette \a global name.

	std::wstring m_paletteName; //!< Palette name.

	int m_version;										   //!< Palette version number.

	std::vector<page *=""> m_pages;						   //!< Pages list.</page>

	std::vector<std::pair<page *,="" tcolorstylep="">> m_styles; //!< Styles container.</std::pair<page>

	std::map<int, int=""> m_shortcuts;</int,>

	StyleAnimationTable m_styleAnimationTable; //!< Table of style animations (per style).

	int m_currentFrame;						   //!< Palette's current frame in style animations.

	bool m_isCleanupPalette;				   //!< Whether the palette is used for cleanup purposes.

	TImageP m_refImg;

	TFilePath m_refImgPath;

	std::vector<tframeid> m_refLevelFids;</tframeid>

	bool m_dirtyFlag; //!< Whether the palette changed and needs to be refreshed.

	QMutex m_mutex;   //!< Synchronization mutex for multithreading purposes.

	bool m_isLocked;		 //!< Whether the palette is locked.

	bool m_askOverwriteFlag; //!< This variable is quite unique. This flag is to acheive following beghavior:

							 //! When saving the level with the palette being edited, ask whether the palette

							 //! should be overwitten ONLY ONCE AT THE FIRST TIME.

							 //! The confirmation dialog will not be opened unless the palette is edited again,

							 //! even if the palette's dirtyflag is true.

public:

	TPalette();

	~TPalette();

	TPalette *clone() const; //!< Allocates a \a new copy of this palette instance.

	static void setRootDir(const TFilePath &fp); //!< It must be specified to save textures in \e fp/textures.

	static TFilePath getRootDir();

	std::wstring getGlobalName() const { return m_globalName; } //!< Returns the name of the palette object.

	void setGlobalName(std::wstring name) { m_globalName = name; }   //!< Assigns the name of the palette.

	void setDirtyFlag(bool dirtyFlag) //!< Declares the palette \a changed with respect to the last saved state.

	{

		m_dirtyFlag = dirtyFlag;

		//synchronize with the dirty flag

		m_askOverwriteFlag = dirtyFlag;

	}

	bool getDirtyFlag() { return m_dirtyFlag; } //!< Returns whether the palette changed with respect to the last saved state.

	TColorStyle *getStyle(int styleId) const;				   //!< Returns a pointer to the color style with the specified id,

															   //!  or \p 0 if said id is not stored in the palette.

	int getStyleCount() const { return (int)m_styles.size(); } //!< Returns the number of the color styles in the palette.

	int getStyleInPagesCount() const;						   //!< Returns the number of styles contained in palette pages.

	int getFirstUnpagedStyle() const; //!< Returns the styleId of the first style not in a page (\p -1 if none).

	/*!

		\remark   Style ownserhip is \a surrendered to the palette

		\return   The styleId associated to the inserted style, or \a -1 on failure.

	*/

	int addStyle(TColorStyle *style);		 //!< Adds the specified style to the palette (but in no page).

	int addStyle(const TPixelRGBM32 &color); //!< Adds a solid color style to the palette (but in no page).

	/*!

    \remark     Style ownserhip is \a surrendered to the palette.

    \remark     Any existing style's animation will be discarded.

  */

	void setStyle(int styleId, TColorStyle *style);		   //!< Replaces the style with the specified style id.

	void setStyle(int styleId, const TPixelRGBM32 &color); //!< Replaces the style with the specified style id.

	int getPageCount() const; //!< Returns the pages count.

	Page *getPage(int pageIndex);			  //!< Returns the \a index-th palette page, or \p 0 if no such page was found.

	const Page *getPage(int pageIndex) const; //!< Const version of getPage(int).

	/*!

    \return  A pointer to the newly created page.

  */

	Page *addPage(std::wstring name); //!< Creates a new page with the specified name.

	void erasePage(int index);   //!< Deletes the \a index-th page.

	void movePage(Page *page, int dstPageIndex); //!< Moves the specified page to a different page index.

	Page *getStylePage(int styleId) const; //!< Returns the page containing the specified \a styleId.

	/*!

    \note   The distance between colors is calculated with the usual sphrical norm between RGBA color components.

    \return The style id of the nearest style, or \p -1 if none was found.

	*/

	int getClosestStyle(const TPixelRGBM32 &color) const; //!< Returns the index of the style whose main color

														  //!  is nearest to the requested one.

	void loadData(TIStream &is); //!< I/O palette save function.

	void saveData(TOStream &os); //!< I/O palette load function.

	int getVersion() const { return m_version; } //!< Returns the palette's version number

	void setVersion(int v) { m_version = v; }	//!< Sets the palette's version number

	void setRefLevelFids(const std::vector<tframeid> fids); //!< Associates the list of frames \e fids to this palette.</tframeid>

	std::vector<tframeid> getRefLevelFids();				//!< Returns the list of frames associated to this palette.</tframeid>

	//! \deprecated  Should be substituted by operator=(const TPalette&).

	void assign(const TPalette *src, bool isFromStudioPalette = false); //!< Copies src's page, color styles an animation table to the

																		//!  correspondig features of the palette.

																		//!  if the palette is copied from studio palette, this function will modify the original names.

	void merge(const TPalette *src, bool isFromStudioPalette = false);  //!< Adds src's styles and pages to the palette.

																		//!  if the palette is merged from studio palette, this function will modify the original names.

	void setAskOverwriteFlag(bool askOverwriteFlag)

	{ //!< Sets the ask-overwrite flag.

		m_askOverwriteFlag = askOverwriteFlag;

	}

	bool getAskOverwriteFlag() { return m_askOverwriteFlag; } //!< Returns the ask-overwrite flag.

	void setIsCleanupPalette(bool on);							 //!< Sets the palette's identity as a cleanup palette.

	bool isCleanupPalette() const { return m_isCleanupPalette; } //!< Returns whether this is a cleanup palette.

	const TImageP &getRefImg() const { return m_refImg; } //!< Returns an image that represents the frame image associated to this palette.

	void setRefImg(const TImageP &img);					  //!< Associates an image to this palette, that is an image in the frame

														  //!  builded or modified using this palette.

	const TFilePath getRefImgPath() const { return m_refImgPath; } //!< Returns the file path of the reference image.

	void setRefImgPath(const TFilePath &fp);					   //!< Sets the path filename of the reference image.

	bool isAnimated() const; //!< Returns whether this palette is animated (styles change through time).

	int getFrame() const;	 //!< Returns the index of the current frame.

	void setFrame(int frame); //!< Sets the index of the current frame.

	bool isKeyframe(int styleId, int frame) const; //!< Returns whether the specified frame is a \a keyframe in styleId's animation

	int getKeyframeCount(int styleId) const;	   //!< Returns the keyframes count in styleId's animation.

	int getKeyframe(int styleId, int index) const; //!< Returns the \a index-th frame in styleId's animation,

												   //!  or \p -1 if it couldn't be found.

	void setKeyframe(int styleId, int frame);	  //!< Sets a keyframe at the specified frame of styleId's animation.

	void clearKeyframe(int styleId, int frame);	//!< Deletes the keyframe at the specified frame of styleId's animation.

	/*!

    \note   Key is an integer between 0 and 9 included.

  */

	int getShortcutValue(int key) const; //!< Returns the style id \a shortcut associated to key,

										 //!  or \p -1 if it couldn't be found.

	/*!

	*/

	int getStyleShortcut(int styleId) const;	 //!< Returns the shortcut associated to styleId, or

												 //!  or \p -1 if it couldn't be found.

	void setShortcutValue(int key, int styleId); //!< Associates the specified key to a styleId.

	void setPaletteName(std::wstring name) { m_paletteName = name; } //!< Sets the name of the palette.

	std::wstring getPaletteName() const { return m_paletteName; }	//!< Returns the name of the palette.

	QMutex *mutex() { return &m_mutex; } //!< Returns the palette's mutex

	bool isLocked() const { return m_isLocked; } //!< Returns whether the palette is locked.

	void setIsLocked(bool lock)					 //!< Sets lock/unlock to the palette.

	{

		m_isLocked = lock;

	}

public:

	// Deprecated functions

	//! \deprecated  Used only once throughout Toonz, should be verified.

	bool getFxRects(

		const TRect &rect,

		TRect &rectIn,

		TRect &rectOut);

private:

	// Not copyable

	TPalette(const TPalette &);			   //!< Not implemented

	TPalette &operator=(const TPalette &); //!< Not implemented

};

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

#ifdef _WIN32

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

#endif

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

#ifdef _WIN32

#pragma warning(pop)

#endif

#endif // TPALETTE_H