#include "tiio_movX.h"
#include "traster.h"
#include "trasterimage.h"
#include "tsound.h"

#ifdef NOTE
Supportato solo RGBM32, sotto NT sarebbe possibile supportare anche 1bpp, ma
																			  mancano i TRaster opportuni...

	viene supportata
	solo(LA PRIMA) traccia video !!!!
#endif

	//namespace {
	enum QTLibError {
		QTNoError = 0x0000,

		QTCantCreateParams = 0x0101,
		QTCantSetParams = 0x0102,
		QTPixelTypeError = 0x0103,
		QTCheckLibError = 0x0104
	};

string buildQTErrorString(int ec)
{
	switch (ec) {
	case QTCantCreateParams:
		return "Unable to create default params";
	case QTCantSetParams:
		return "Unable to set default params";
	case QTPixelTypeError:
		return "Unsupported pixel type";
	case QTCheckLibError:
		return mvGetErrorStr(mvGetErrno());
	default:
		return "Unknown error";
	}
}
//}
//-----------------------------------------------------------
//  TImageWriterMov
//-----------------------------------------------------------

class TImageWriterMov : public TImageWriter
{

public:
	TImageWriterMov(const TFilePath &, int frameIndex, TLevelWriterMov *);
	~TImageWriterMov() {}
	bool is64bitOutputSupported() { return false; }

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

public:
	void save(const TImageP &);
	int m_frameIndex;

private:
	TLevelWriterMov *m_lwm;
};

//-----------------------------------------------------------
//  TImageReaderMov
//-----------------------------------------------------------
class TImageReaderMov : public TImageReader
{

public:
	TImageReaderMov(const TFilePath &, int frameIndex, TLevelReaderMov *);
	~TImageReaderMov() {}

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

public:
	TImageP load();
	int m_frameIndex;

	TDimension getSize() const { return TDimension(m_lrm->m_lx, m_lrm->m_ly); }
	TRect getBBox() const { return TRect(0, 0, m_lrm->m_lx - 1, m_lrm->m_ly - 1); }

private:
	TLevelReaderMov *m_lrm;
};

//-----------------------------------------------------------
//-----------------------------------------------------------
//        TImageWriterMov
//-----------------------------------------------------------

TImageWriterMov::TImageWriterMov(const TFilePath &path, int frameIndex, TLevelWriterMov *lwm)
	: TImageWriter(path), m_lwm(lwm), m_frameIndex(frameIndex)
{
}

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

void TImageWriterMov::save(const TImageP &img)
{
	TRasterImageP image(img);
	int lx = image->getRaster()->getLx();
	int ly = image->getRaster()->getLy();
	void *buffer = image->getRaster()->getRawData();
	int pixSize = image->getRaster()->getPixelSize();
	if (pixSize != 4)
		throw TImageException(m_lwm->getFilePath(), "Unsupported pixel type");

	if (!m_lwm->m_initDone) {
		DMparams *imageTrackParams;

		if (dmParamsCreate(&imageTrackParams) != DM_SUCCESS)
			throw TImageException(m_lwm->getFilePath(), "Unable to create image track params");

		if (dmSetImageDefaults(imageTrackParams, lx, ly, DM_IMAGE_PACKING_XRGB) != DM_SUCCESS) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to set image defaults");
		}

		if (dmParamsSetFloat(imageTrackParams, DM_IMAGE_RATE, (double)m_lwm->m_rate) != DM_SUCCESS) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to set frame rate");
		}

		if (dmParamsSetEnum(imageTrackParams, DM_IMAGE_ORIENTATION, DM_TOP_TO_BOTTOM) != DM_SUCCESS) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to set frame rate");
		}

		if (dmParamsSetFloat(imageTrackParams, DM_IMAGE_QUALITY_SPATIAL, m_lwm->quality) != DM_SUCCESS) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to set quality");
		}

		if (dmParamsSetString(imageTrackParams, DM_IMAGE_COMPRESSION, m_lwm->compression) != DM_SUCCESS) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to set compression");
		}

		if (mvAddTrack(m_lwm->id, DM_IMAGE, imageTrackParams, NULL, &(m_lwm->imageTrack)) == DM_FAILURE) {
			dmParamsDestroy(imageTrackParams);
			throw TImageException(m_lwm->getFilePath(), "Unable to add image track to movie");
		}

		dmParamsDestroy(imageTrackParams);
		m_lwm->m_initDone = true;
	}

	if (mvInsertFrames(m_lwm->imageTrack, m_frameIndex, 1,
					   lx * ly * pixSize, buffer) != DM_SUCCESS) {
		throw TImageException(m_lwm->getFilePath(), "Unable to write image to movie");
	}
}

//-----------------------------------------------------------
//        TLevelWriterMov
//-----------------------------------------------------------

class TWriterInfoMov : public TWriterInfo
{
public:
	TWriterInfoMov() : TWriterInfo() { assert(!"Not implemented"); }
	~TWriterInfoMov() {}
private:
};

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

TLevelWriterMov::TLevelWriterMov(const TFilePath &path)
	: TLevelWriter(path), m_initDone(false), m_rate(25), m_IOError(QTNoError), quality(DM_IMAGE_QUALITY_NORMAL), compression(DM_IMAGE_QT_ANIM), m_writerInfo(new TWriterInfoMov())
{
	DMparams *movieParams;

	if (dmParamsCreate(&movieParams) != DM_SUCCESS) {
		m_IOError = QTCantCreateParams;
		return;
	}

	if (mvSetMovieDefaults(movieParams, MV_FORMAT_QT) != DM_SUCCESS) {
		dmParamsDestroy(movieParams);
		m_IOError = QTCantCreateParams;
		return;
	}
	if (mvCreateFile(path.getFullPath().c_str(),
					 movieParams, NULL, &id) == DM_FAILURE) {
		static char m[1024];
		dmParamsDestroy(movieParams);
		m_IOError = QTCheckLibError;
		return;
	}

	dmParamsDestroy(movieParams);
}

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

void TLevelWriterMov::saveSoundTrack(TSoundTrack *)
{
	throw TImageException(m_path, "TLevelWriterMov::saveSoundTrack not Implemented");
}
//-----------------------------------------------------------

TWriterInfo *TLevelWriterMov::getWriterInfo() const
{
	return m_writerInfo;
}

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

TLevelWriterMov::~TLevelWriterMov()
{
	bool rc = (mvClose(id) == DM_SUCCESS);
	//if (!rc)
	//  throw TImageException(getFilePath(), "Error closing mov file");
}

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

TImageWriterP TLevelWriterMov::getFrameWriter(TFrameId fid)
{
	if (m_IOError)
		throw TImageException(m_path, buildQTErrorString(m_IOError));
	if (fid.getLetter() != 0)
		return TImageWriterP(0);
	int index = fid.getNumber() - 1;

	TImageWriterMov *iwm = new TImageWriterMov(m_path, index, this);
	return TImageWriterP(iwm);
}

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

TLevelReaderMov::TLevelReaderMov(const TFilePath &path)
	: TLevelReader(path), IOError(QTNoError)

{
	m_status = mvOpenFile(path.getFullPath().c_str(), O_RDONLY, &movie);
	if (m_status != DM_SUCCESS) {
		IOError = QTCheckLibError;
		return;
	}
	track = 0;
	m_status = mvFindTrackByMedium(movie, DM_IMAGE, &track);
	if (m_status != DM_SUCCESS) {
		IOError = QTCheckLibError;
		return;
	}
	m_lx = mvGetImageWidth(track);
	m_ly = mvGetImageHeight(track);
	DMpacking packing = mvGetImagePacking(track);
	if (packing != DM_IMAGE_PACKING_XRGB) {
		IOError = QTPixelTypeError;
		return;
	}
}

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

//------------------------------------------------
// TImageReaderMov
//------------------------------------------------

TImageReaderMov::TImageReaderMov(const TFilePath &path, int frameIndex, TLevelReaderMov *lrm)
	: TImageReader(path), m_lrm(lrm), m_frameIndex(frameIndex)
{
}

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

TLevelReaderMov::~TLevelReaderMov()
{
	mvClose(movie);
}

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

TLevelP TLevelReaderMov::loadInfo()
{
	TLevelP level;
	if (IOError != QTNoError)
		throw TImageException(m_path, buildQTErrorString(IOError));

	if (!track)
		throw TImageException(getFilePath().getFullPath().c_str(), " error reading info");

	MVframe nFrames = mvGetTrackLength(track);
	if (nFrames == -1)
		return level;
	for (int i = 1; i <= nFrames; i++)
		level->setFrame(TFrameId(i), TImageP());
	return level;
}

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

TImageP TImageReaderMov::load()
{
	TRaster32P ret(m_lrm->m_lx, m_lrm->m_ly);

	DMstatus status = mvReadFrames(m_lrm->track, m_frameIndex, 1, m_lrm->m_lx * m_lrm->m_ly * 4, ret->getRawData());
	if (status != DM_SUCCESS) {
		throw TImageException(getFilePath().getFullPath().c_str(), mvGetErrorStr(mvGetErrno()));
	}

	// getImage()->setRaster(ret);
	return TRasterImageP(ret);
}

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

TImageReaderP TLevelReaderMov::getFrameReader(TFrameId fid)
{
	if (IOError != QTNoError)
		throw TImageException(m_path, buildQTErrorString(IOError));

	if (fid.getLetter() != 0)
		return TImageReaderP(0);
	int index = fid.getNumber() - 1;

	TImageReaderMov *irm = new TImageReaderMov(m_path, index, this);
	return TImageReaderP(irm);
}