// TnzCore includes

#include "tstream.h"

#include "timageinfo.h"

#include "tmeshimage.h"

#include "tiio_mesh.h"

// TODO: Eccezioni. Vedi come funziona in toonzscene.cpp

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

//    TImageWriterMesh  definition

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

class TImageWriterMesh : public TImageWriter

{

	TFrameId m_fid; //!< The frame id

public:

	TImageWriterMesh(const TFilePath &fp, const TFrameId &frameId);

	~TImageWriterMesh() {}

public:

	void save(const TImageP &);

private:

	TImageWriterMesh(const TImageWriterMesh &);

	TImageWriterMesh &operator=(const TImageWriterMesh &src);

};

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

TImageWriterMesh::TImageWriterMesh(const TFilePath &fp, const TFrameId &frameId)

	: TImageWriter(fp), m_fid(frameId)

{

}

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

void TImageWriterMesh::save(const TImageP &img)

{

	TFilePath imagePath(this->m_path.withFrame(m_fid));

	TOStream ostream(imagePath, true); // Use compression

	TMeshImageP mi = img;

	// Save Header

	ostream.openChild("header");

	{

		// Save version

		ostream.openChild("version");

		ostream << 1 << 19;

		ostream.closeChild();

		// Save dpi

		ostream.openChild("dpi");

		double dpiX, dpiY;

		mi->getDpi(dpiX, dpiY);

		ostream << dpiX << dpiY;

		ostream.closeChild();

	}

	ostream.closeChild();

	// Save meshes

	const std::vector<ttexturemeshp> &meshes = mi->meshes();</ttexturemeshp>

	int m, mCount = meshes.size();

	for (m = 0; m < mCount; ++m) {

		ostream.openChild("mesh");

		ostream << *meshes[m];

		ostream.closeChild();

	}

}

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

//    TImageReaderMesh  definition

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

class TImageReaderMesh : public TImageReader

{

	TFrameId m_fid;			   //

	mutable TImageInfo m_info; //!< The image's infos

public:

	TImageReaderMesh(const TFilePath &fp, const TFrameId &frameId);

	~TImageReaderMesh() {}

	const TImageInfo *getImageInfo() const;

	TImageP load();

private:

	//! Reference to level reader

	TLevelReaderMesh *m_lrp;

private:

	void readHeader(TIStream &is) const;

	// not implemented

	TImageReaderMesh(const TImageReaderMesh &);

	TImageReaderMesh &operator=(const TImageReaderMesh &src);

};

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

TImageReaderMesh::TImageReaderMesh(const TFilePath &fp, const TFrameId &frameId)

	: TImageReader(fp), m_fid(frameId)

{

}

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

const TImageInfo *TImageReaderMesh::getImageInfo() const

{

	if (!m_info.m_valid) {

		// Load info from file

		TFilePath imagePath(this->m_path.withFrame(m_fid));

		TIStream is(imagePath);

		readHeader(is);

	}

	return &m_info;

}

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

void TImageReaderMesh::readHeader(TIStream &is) const

{

	std::string tagName;

	// Open header tag

	is.openChild(tagName);

	assert(tagName == "header");

	{

		// Read header entries

		while (is.openChild(tagName)) {

			if (tagName == "version") {

				int major, minor;

				is >> major >> minor;

				is.setVersion(VersionNumber(major, minor));

				is.closeChild();

			} else if (tagName == "dpi") {

				is >> m_info.m_dpix >> m_info.m_dpiy;

				assert(m_info.m_dpix > 0.0 && m_info.m_dpiy > 0.0);

				is.closeChild();

			} else

				is.skipCurrentTag();

		}

	}

	is.closeChild();

	m_info.m_valid = true;

}

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

TImageP TImageReaderMesh::load()

{

	TMeshImageP mi(new TMeshImage);

	TFilePath imagePath(this->m_path.withFrame(m_fid));

	TIStream is(imagePath);

	readHeader(is);

	mi->setDpi(m_info.m_dpix, m_info.m_dpiy);

	// Meshes

	std::vector<ttexturemeshp> &meshes = mi->meshes();</ttexturemeshp>

	std::string tagName;

	while (is.openChild(tagName)) {

		if (tagName == "mesh") {

			meshes.push_back(new TTextureMesh);

			is >> *meshes.back();

			is.closeChild();

		} else

			is.skipCurrentTag();

	}

	return mi;

}

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

//    TLevelWriterMesh  implementation

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

TLevelWriterMesh::TLevelWriterMesh(const TFilePath &path, TPropertyGroup *winfo)

	: TLevelWriter(path, winfo)

{

}

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

TLevelWriterMesh::~TLevelWriterMesh()

{

}

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

TImageWriterP TLevelWriterMesh::getFrameWriter(TFrameId fid)

{

	return new TImageWriterMesh(this->m_path, fid);

}

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

//    TLevelReaderMesh  implementation

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

TLevelReaderMesh::TLevelReaderMesh(const TFilePath &path)

	: TLevelReader(path)

{

}

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

TLevelReaderMesh::~TLevelReaderMesh()

{

}

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

TImageReaderP TLevelReaderMesh::getFrameReader(TFrameId fid)

{

	return new TImageReaderMesh(this->m_path, fid);

}