#include "tiio_psd.h"
#include "trasterimage.h"
#include "timageinfo.h"

// forward declaration
//class TImageReaderLayerPsd;

// if path = :
//  filename.psd									to load float image. TLevel frames number is 1
//	filename#layerId.psd					to load only one psd layer from layerId. TLevel frames number is 1
//  filename#layerId#frames.psd	  to load only one psd layer from layerId. TLevel frames number is psd layers number
//  filename#layerId#group.psd		to load only one psd layer from layerId. TLevel frames number is psd layers folder number \
//																where fodler is the folder belongs psd layer.

TLevelReaderPsd::TLevelReaderPsd(const TFilePath &path)
	: TLevelReader(path), m_path(path), m_layerId(0)
{
	m_psdreader = new TPSDReader(m_path);
	TPSDHeaderInfo header = m_psdreader->getPSDHeaderInfo();
	m_lx = header.cols;
	m_ly = header.rows;
	m_layersCount = header.layersCount;
	// set m_info
	m_info = new TImageInfo();
	m_info->m_lx = m_lx;
	m_info->m_ly = m_ly;
	m_info->m_dpix = header.hres;
	m_info->m_dpiy = header.vres;
	m_info->m_bitsPerSample = header.depth;
	m_info->m_samplePerPixel = header.channels;

	QString name = m_path.getName().c_str();
	QStringList list = name.split("#");
	if (list.size() >= 2) {
		// There's a layer id, otherwise the level is loaded in FLAT mode
		const QString &layerStr = list.at(1);

#ifdef REF_LAYER_BY_NAME
		if (layerStr != "frames") {
			TPSDParser psdparser(m_path);
			m_layerId = psdparser.getLevelIdByName(layerStr.toStdString());
		} else
			m_layerId = layerStr.toInt();
#else
		m_layerId = layerName.toInt();
#endif
	}
}

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

TLevelReaderPsd::~TLevelReaderPsd()
{
	delete m_psdreader;
}

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

void TLevelReaderPsd::load(TRasterImageP &rasP, int shrinkX, int shrinkY, TRect region)
{
	QMutexLocker sl(&m_mutex);
	TRasterImageP img;
	m_psdreader->setShrink(shrinkX, shrinkY);
	m_psdreader->setRegion(region);
	m_psdreader->load(img, m_layerId); // if layerId==0 load Merged
	rasP = img;
}

TLevelP TLevelReaderPsd::loadInfo()
{
	TPSDParser *psdparser = new TPSDParser(m_path);
	assert(m_layerId >= 0);
	int framesCount = psdparser->getFramesCount(m_layerId);
	TLevelP level;
	level->setName(psdparser->getLevelName(m_layerId));
	m_frameTable.clear();
	for (int i = 0; i < framesCount; i++) {
		TFrameId frame(i + 1);
		m_frameTable.insert(make_pair(frame, psdparser->getFrameId(m_layerId, i)));
		level->setFrame(frame, TImageP());
	}
	return level;
}

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

TLevelReader *TLevelReaderPsd::create(const TFilePath &f)
{
	TLevelReaderPsd *reader = new TLevelReaderPsd(f);
	return reader;
}

//-----------------------------------------------------------
//  TImageReaderLayerPsd
//-----------------------------------------------------------

class TImageReaderLayerPsd : public TImageReader
{

public:
	TImageReaderLayerPsd(const TFilePath &, int layerId, TLevelReaderPsd *lr, TImageInfo *info);
	~TImageReaderLayerPsd() { m_lr->release(); }

private:
	//not implemented
	TImageReaderLayerPsd(const TImageReaderLayerPsd &);
	TImageReaderLayerPsd &operator=(const TImageReaderLayerPsd &src);

public:
	TImageP load();

	const TImageInfo *getImageInfo() const { return m_info; }

private:
	TPSDReader *m_psdreader;
	TLevelReaderPsd *m_lr;
	TImageInfo *m_info;
	int m_layerId;
};

TImageReaderLayerPsd::TImageReaderLayerPsd(const TFilePath &path, int layerId, TLevelReaderPsd *lr, TImageInfo *info)
	: TImageReader(path), m_lr(lr), m_layerId(layerId), m_info(info)
{
	m_lr->setLayerId(layerId);
	m_lr->addRef();
}

TImageP TImageReaderLayerPsd::load()
{
	TRasterImageP rasP;
	m_lr->load(rasP, m_shrink, m_shrink, m_region);
	return TRasterImageP(rasP);
}

TImageReaderP TLevelReaderPsd::getFrameReader(TFrameId fid)
{
	int layerId = m_frameTable[fid];
	TImageReaderLayerPsd *ir = new TImageReaderLayerPsd(m_path, layerId, this, m_info);
	return TImageReaderP(ir);
}

//------------------------------------------------------------------------------
//  TImageWriterPsd
//------------------------------------------------------------------------------

class TImageWriterPsd : public TImageWriter
{

	int m_layerId;

public:
	TImageWriterPsd(const TFilePath &, int frameIndex, TLevelWriterPsd *);
	~TImageWriterPsd() { m_lwm->release(); }

private:
	//not implemented
	TImageWriterPsd(const TImageWriterPsd &);
	TImageWriterPsd &operator=(const TImageWriterPsd &src);

public:
	//not implemented
	void save(const TImageP &);

private:
	TLevelWriterPsd *m_lwm;
};

//-----------------------------------------------------------
//-----------------------------------------------------------
//        TImageWriterPsd
//-----------------------------------------------------------

TImageWriterPsd::TImageWriterPsd(const TFilePath &path, int layerId, TLevelWriterPsd *lwm)
	: TImageWriter(path), m_lwm(lwm), m_layerId(layerId)
{
	m_lwm->addRef();
}

//-----------------------------------------------------------
void TImageWriterPsd::save(const TImageP &img)
{
	m_lwm->save(img, m_layerId);
}

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

void TLevelWriterPsd::save(const TImageP &img, int frameIndex)
{
}

//-----------------------------------------------------------
//        TLevelWriterPsd
//-----------------------------------------------------------

TLevelWriterPsd::TLevelWriterPsd(const TFilePath &path, TPropertyGroup *winfo)
	: TLevelWriter(path, winfo)
{
}

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

TLevelWriterPsd::~TLevelWriterPsd()
{
}

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

TImageWriterP TLevelWriterPsd::getFrameWriter(TFrameId fid)
{
	int layerId = 0;
	TImageWriterPsd *iwm = new TImageWriterPsd(m_path, layerId, this);
	return TImageWriterP(iwm);
}