#ifndef PSD_INCLUDED
#define PSD_INCLUDED

#include "psdutils.h"
#include "timage_io.h"

#define REF_LAYER_BY_NAME

class TRasterImageP;

#undef DVAPI
#undef DVVAR

#ifdef TNZCORE_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

// Photoshop's mode
#define ModeBitmap 0
#define ModeGrayScale 1
#define ModeIndexedColor 2
#define ModeRGBColor 3
#define ModeCMYKColor 4
#define ModeHSLColor 5
#define ModeHSBColor 6
#define ModeMultichannel 7
#define ModeDuotone 8
#define ModeLabColor 9
#define ModeGray16 10
#define ModeRGB48 11
#define ModeLab48 12
#define ModeCMYK64 13
#define ModeDeepMultichannel 14
#define ModeDuotone16 15

struct TPSDLayerMaskInfo {
	psdByte size;
	long top;
	long left;
	long bottom;
	long right;
	char default_colour;
	char flags;

	psdPixel rows, cols;
};

struct TPSDBlendModeInfo {
	char sig[4];
	char key[4];
	unsigned char opacity;
	unsigned char clipping;
	unsigned char flags;
};

struct TPSDLayerInfo {
	long top;
	long left;
	long bottom;
	long right;
	short channels;

	TPSDChannelInfo *chan;
	int *chindex;

	unsigned long layerId;
	unsigned long protect;
	unsigned long section;
	unsigned long foreignEffectID;
	unsigned long layerVersion;

	int blendClipping;
	int blendInterior;
	int knockout;
	int transparencyShapes;
	int layerMaskAsGlobalMask;
	int vectorMaskAsGlobalMask;

	TPSDBlendModeInfo blend;
	TPSDLayerMaskInfo mask;

	double referencePointX;
	double referencePointY;

	char *name;
	char *nameno; // "layerNr"
	char *unicodeName;
	char *layerNameSource;
	psdByte additionalpos;
	psdByte additionallen;
	psdByte filepos; //

	psdByte startDataPos; // Posizione di inizio dati all'interno del file
	psdByte dataLength;   // lunghezza dati

	// LAYER EFFECTS
	unsigned long int *fxCommonStateVersion;
	int fxCommonStateVisible;
	unsigned long int fxShadowVersion;
	float fxShadowBlur;
	float fxShadowIntensity;
	float fxShadowAngle;
	float fxShadowDistance;

	//my tags
	bool isFolder;
};

struct TPSDHeaderInfo {

	char sig[4];
	short version;
	char reserved[6];
	short channels;
	long rows;
	long cols;
	short depth;
	short mode;
	double vres; // image resource. Vertical resolution
	double hres; // image resource. Horizontal resolution

	psdByte colormodepos;
	int layersCount;
	int mergedalpha;
	bool linfoBlockEmpty;
	TPSDLayerInfo *linfo;	 // array of layer info
	psdByte lmistart, lmilen; // set by doLayerAndMaskInfo()
	psdByte layerDataPos;	 //set by doInfo
};

struct dictentry {
	int id;
	char *key, *tag, *desc;
	void (*func)(FILE *f, struct dictentry *dict, TPSDLayerInfo *li);
};

// PSD LIB
// Restituisce eccezioni
class DVAPI TPSDReader
{
	TFilePath m_path;
	FILE *m_file;
	int m_lx, m_ly;
	TPSDHeaderInfo m_headerInfo;
	int m_layerId;
	int m_shrinkX;
	int m_shrinkY;
	TRect m_region;

public:
	TPSDReader(const TFilePath &path);
	~TPSDReader();
	TImageReaderP getFrameReader(TFilePath path);
	TPSDHeaderInfo getPSDHeaderInfo();

	void load(TRasterImageP &rasP, int layerId);
	TDimension getSize() const { return TDimension(m_lx, m_ly); }
	TPSDLayerInfo *getLayerInfo(int index);
	int getLayerInfoIndexById(int layerId);
	void setShrink(int shrink)
	{
		m_shrinkX = shrink;
		m_shrinkY = shrink;
	}
	void setShrink(int shrinkX, int shrinkY)
	{
		m_shrinkX = shrinkX;
		m_shrinkY = shrinkY;
	}
	void setRegion(TRect region) { m_region = region; }

	int getShrinkX() { return m_shrinkX; }
	int getShrinkY() { return m_shrinkY; }
	TRect getRegion() { return m_region; }

private:
	std::map<int, TRect> m_layersSavebox;

	bool doInfo();
	bool doHeaderInfo();
	bool doColorModeData();
	bool doImageResources();
	bool doLayerAndMaskInfo();
	bool doLayersInfo();
	bool readLayerInfo(int index);

	//void doImage(unsigned char *rasP, TPSDLayerInfo *li);
	void doImage(TRasterP &rasP, int layerId);

	void readImageData(TRasterP &rasP, TPSDLayerInfo *li, TPSDChannelInfo *chan,
					   int chancount, psdPixel rows, psdPixel cols);
	int m_error;
	TThread::Mutex m_mutex;
	int openFile();

	void doExtraData(TPSDLayerInfo *li, psdByte length);
	int sigkeyblock(FILE *f, struct dictentry *dict, TPSDLayerInfo *li);
	struct dictentry *findbykey(FILE *f, struct dictentry *parent, char *key, TPSDLayerInfo *li);
};

// converts psd layers structure into toonz level structure	according to path
class DVAPI TPSDParser
{

	class Level
	{
	public:
		Level(std::string nm = "Unknown", int lid = 0, bool is_folder = false) : name(nm),
																			layerId(lid),
																			folder(is_folder)
		{
		}
		void addFrame(int layerId, bool isFolder = false) { framesId.push_back(Frame(layerId, isFolder)); }
		int getFrameCount() { return (int)framesId.size(); }
		std::string getName() { return name; }
		int getLayerId() { return layerId; }
		void setName(std::string nname) { name = nname; }
		void setLayerId(int nlayerId) { layerId = nlayerId; }
		int getFrameId(int index)
		{
			assert(index >= 0 && index < (int)framesId.size());
			return framesId[index].layerId;
		}
		// return true if frame is a subfolder
		bool isSubFolder(int frameIndex)
		{
			assert(frameIndex >= 0 && frameIndex < (int)framesId.size());
			return framesId[frameIndex].isFolder;
		}
		// return true if the level is built from a psd folder
		bool isFolder() { return folder; }
	private:
		struct Frame {
			int layerId; // psd layerId
			bool isFolder;
			Frame(int layId, bool folder) : layerId(layId), isFolder(folder)
			{
			}
		};

		std::string name;				 // psd name
		int layerId;				 // psd layer id
		std::vector<Frame> framesId; // array of layer ID as frame
		bool folder;
	};

	TFilePath m_path;
	std::vector<Level> m_levels; // layers id
	TPSDReader *m_psdreader;	 //lib
public:
	// path define levels construction method
	// if path = :
	//  filename.psd										flat image so LevelsCount = 1;
	//	filename#LAYERID.psd						each psd layer as a tlevel
	//  filename#LAYERID#frames.psd			each psd layer as a frame so there is only one tlevel with 1 or more frames;
	//  filename#LAYERID#folder.psd			each psd layer is a tlevel and	\
		//																	each folder is a tlevel such as the psd layers \
		//																	contained into folder are frames of tlevel
	// LAYERID(Integer) is psd layerId
	TPSDParser(const TFilePath &path);
	~TPSDParser();
	int getLevelsCount() { return (int)m_levels.size(); }
	// load a psd layer
	// if layerId == 0 load flat image
	void load(TRasterImageP &rasP, int layerId = 0);

	// Returns psd layerID
	int getLevelId(int index)
	{
		assert(index >= 0 && index < (int)m_levels.size());
		return m_levels[index].getLayerId();
	}
	bool isFolder(int levelIndex)
	{
		assert(levelIndex >= 0 && levelIndex < (int)m_levels.size());
		return m_levels[levelIndex].isFolder();
	}
	int getLevelIndexById(int levelId);
	// Returns layerID by name. Note that the layer name is not unique, so it return the first layer id found.
	int getLevelIdByName(std::string levelName);
	int getFrameId(int layerId, int frameIndex) { return m_levels[getLevelIndexById(layerId)].getFrameId(frameIndex); }
	int getFramesCount(int levelId);
	bool isSubFolder(int levelIndex, int frameIndex)
	{
		assert(levelIndex >= 0 && levelIndex < (int)m_levels.size());
		return m_levels[levelIndex].isSubFolder(frameIndex);
	}
	std::string getLevelName(int levelId);
	// Returns level name.
	// If there are 2 or more level with the same name then
	// returns levelname, levelname__2, etc
	std::string getLevelNameWithCounter(int levelId);

private:
	void doLevels(); // do m_levels
};

#endif //TIIO_PSD_H