#pragma once

#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;

	const 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;</int,>

	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 framesId; // array of layer ID as frame

		bool folder;

	};

	TFilePath m_path;

	std::vector<level> m_levels; // layers id</level>

	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