// 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();

	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;			   //<! Current frame id
	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();

	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);
}