#include "ttest.h"

#include "tsystem.h"

#include "tfilepath_io.h"

#include "tlevel_io.h"

#include "tfx.h"

#include "tparam.h"

#include "tpalette.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "tstroke.h"

#include "tcolorstyles.h"

#include <set></set>

#if defined(LINUX)

#include <typeinfo></typeinfo>

#endif

using namespace std;

namespace

{

class TTestTable

{

	typedef map<std::string, *="" ttest=""> Table;</std::string,>

	typedef set<std::string> SkipTable;</std::string>

	Table m_table;

	SkipTable m_skipTable;

	TTestTable(){};

public:

	static TTestTable *table()

	{

		static TTestTable *theTable = 0;

		if (!theTable)

			theTable = new TTestTable;

		return theTable;

	}

	void add(const std::string &str, TTest *test)

	{

		assert(test);

		if (m_table.find(str) != m_table.end()) {

			cout << "*error* Duplicate test name '" << str << "'" << endl;

			assert(0);

			return;

		}

		m_table[str] = test;

	}

	void skip(const std::string &str)

	{

		m_skipTable.insert(str);

	}

	void run(const std::string &str)

	{

		if (m_skipTable.find(str) != m_skipTable.end())

			return;

		Table::iterator it = m_table.find(str);

		if (it == m_table.end())

			cout << "*error* test '" << str << "' not found" << endl;

		else {

			cout << "\nVerifying " << str << " ... " << endl;

			it->second->before();

			it->second->test();

			it->second->after();

			cout << "OK" << endl;

		}

	}

	void runAll()

	{

		int count = 0;

		cout << "Running all tests:" << endl;

		Table::iterator it;

		for (it = m_table.begin(); it != m_table.end(); ++it) {

			run(it->first);

			++count;

		}

		cout << count << " test(s) launched" << endl;

	}

	void runType(string type)

	{

		int count = 0;

		cout << "Running " << type << " tests:" << endl;

		Table::iterator it;

		for (it = m_table.begin(); it != m_table.end(); ++it) {

			string str(it->first);

			int i = str.find("_");

			if (i <= 0)

				continue;

			string subStr(str, 0, i);

			if (subStr == type)

				run(it->first);

			++count;

		}

		cout << count << " test(s) launched" << endl;

	}

};

}

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

TTest::TTest(const std::string &testName)

{

	TTestTable::table()->add(testName, this);

}

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

TTest::~TTest()

{

}

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

void TTest::setInstanceCount()

{

	m_levelInstanceCount = TLevel::getInstanceCount();

	m_imageInstanceCount = TImage::getInstanceCount();

	m_rasterInstanceCount = TRaster::getInstanceCount();

	m_imageReaderInstanceCount = TImageReader::getInstanceCount();

	m_imageWriterInstanceCount = TImageWriter::getInstanceCount();

	m_levelReaderInstanceCount = TLevelReader::getInstanceCount();

	m_levelWriterInstanceCount = TLevelWriter::getInstanceCount();

	m_paramInstanceCount = TParam::getInstanceCount();

	m_fxInstanceCount = TFx::getInstanceCount();

}

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

void TTest::verifyInstanceCount()

{

	assert(m_levelInstanceCount == TLevel::getInstanceCount());

	assert(m_imageInstanceCount == TImage::getInstanceCount());

	//assert(m_rasterInstanceCount==TRaster::getInstanceCount());

	// commentata da gmt: in qualche test viene creata un

	// offline gl context con annesso raster che ovviamente non

	// viene liberato.

	assert(m_imageReaderInstanceCount == TImageReader::getInstanceCount());

	assert(m_imageWriterInstanceCount == TImageWriter::getInstanceCount());

	assert(m_levelReaderInstanceCount == TLevelReader::getInstanceCount());

	assert(m_levelWriterInstanceCount == TLevelWriter::getInstanceCount());

	assert(m_paramInstanceCount == TParam::getInstanceCount());

	assert(m_fxInstanceCount == TFx::getInstanceCount());

}

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

void TTest::runTests(string name)

{

	TFilePath testFile = getTestFile(name);

	std::vector<std::string> testType;</std::string>

	if (name == "verif_image") {

		testType.push_back("write");

		testType.push_back("read");

	}

	Tifstream is(testFile);

	if (!is) {

		cout << "*error* test file '" << testFile << "' not found" << endl;

		return;

	}

	cout << "Test file : '" << testFile << "'" << endl;

	char buffer[1024];

	while (is.getline(buffer, sizeof(buffer))) {

		istrstream ss(buffer);

		while (ss) {

			string s;

			ss >> s;

			if (s == "")

				continue;

			if (s[0] == '#' || s[0] == '!')

				break;

			//Verifica tutti i test

			if (s == "all") {

				TTestTable::table()->runAll();

				continue;

			}

			//Verifica una parte dei test che ha come nome iniziale testType[i]

			int i;

			bool isTypeFound = false;

			for (i = 0; i < (int)testType.size(); i++)

				if (s == testType[i]) {

					isTypeFound = true;

					TTestTable::table()->runType(testType[i]);

					break;

				}

			if (isTypeFound)

				continue;

			if (s[0] == '~')

				TTestTable::table()->skip(s.substr(1));

			else //Verifica il test di nome s

				TTestTable::table()->run(s);

		}

	}

}

//================================================================================

// Utility

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

TFilePath getTestFile(string name)

{

	TFilePath testFile;

	TFilePath parentDir = TSystem::getBinDir().getParentDir();

#ifndef _WIN32

	parentDir = parentDir.getParentDir();

#endif

	TFilePath relativePath;

#ifndef NDEBUG

	relativePath = parentDir + TFilePath("projects\\test\\") + TFilePath(name);

#endif

	if (name == "verify_tnzcore")

		testFile = relativePath + TFilePath(name).withType("txt");

	else if (name == "verify_toonzlib")

		testFile = relativePath + TFilePath(name).withType("txt");

	else if (name == "verify_image")

		testFile = relativePath + TFilePath(name).withType("txt");

	else

		testFile = parentDir + TFilePath(name).withType("txt");

	return testFile;

}

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

/*!

*  Return true if \b ra raster and \b rb raster are equal, with an error

*  less than \b err; return false otherwise.

*  To verify rasters parity check pixel raster; if rasters are different is

*	 showed an error message.

*

*  \b err max variance allowed to value pixels.

*

*  OSS.: Usually \b ra is check image and \b rb reference image.

*/

int areEqual(TRasterP ra, TRasterP rb, double err)

{

	if (!ra && !rb)

		return true;

	int y, x;

	if (typeid(ra) != typeid(rb))

		return false;

	if (!ra || !rb)

		return false;

	if (ra->getSize() != rb->getSize())

		return false;

	const int rowSize = ra->getRowSize();

	TRaster32P ra32 = ra;

	TRaster64P ra64 = ra;

	TRasterGR8P raGR8 = ra;

	TRasterCM32P raCM32 = ra;

	if (ra32) {

		TRaster32P rb32 = rb;

		if (!rb32)

			return 2;

		for (y = 0; y < ra->getLy(); y++)

			for (x = 0; x < ra->getLx(); x++) {

				TPixel32 *apix = (TPixel32 *)ra->getRawData(x, y);

				TPixel32 *bpix = (TPixel32 *)rb->getRawData(x, y);

				int rA = apix->r;

				int gA = apix->g;

				int bA = apix->b;

				int mA = apix->m;

				int rB = bpix->r;

				int gB = bpix->g;

				int bB = bpix->b;

				int mB = bpix->m;

				if (!areAlmostEqual(double(rA), double(rB), err) ||

					!areAlmostEqual(double(gA), double(gB), err) ||

					!areAlmostEqual(double(bA), double(bB), err) ||

					!areAlmostEqual(double(mA), double(mB), err)) {

					cout << "MISMATCH: x=" << x << " y=" << y

						 << ". Pixel a = (" << (int)rA << "," << (int)gA << ","

						 << (int)bA << "," << (int)mA << ")"

						 << ". Pixel b = (" << (int)rB << "," << (int)gB << ","

						 << (int)bB << "," << (int)mB << ")" << endl;

					return false;

				}

			}

	} else if (ra64) {

		TRaster64P rb64 = rb;

		if (!rb64)

			return 2;

		for (y = 0; y < ra->getLy(); y++)

			for (x = 0; x < ra->getLx(); x++) {

				TPixel64 *apix = (TPixel64 *)ra->getRawData(x, y);

				TPixel64 *bpix = (TPixel64 *)rb->getRawData(x, y);

				int rA = apix->r;

				int gA = apix->g;

				int bA = apix->b;

				int mA = apix->m;

				int rB = bpix->r;

				int gB = bpix->g;

				int bB = bpix->b;

				int mB = bpix->m;

				if (!areAlmostEqual(double(rA), double(rB), err) ||

					!areAlmostEqual(double(gA), double(gB), err) ||

					!areAlmostEqual(double(bA), double(bB), err) ||

					!areAlmostEqual(double(mA), double(mB), err)) {

					cout << "MISMATCH: x=" << x << " y=" << y

						 << ". Pixel a = (" << (int)rA << "," << (int)gA << ","

						 << (int)bA << "," << (int)mA << ")"

						 << ". Pixel b = (" << (int)rB << "," << (int)gB << ","

						 << (int)bB << "," << (int)mB << ")" << endl;

					return false;

				}

			}

	} else if (raGR8) {

		TRasterGR8P rbGR8 = rb;

		if (!rbGR8)

			return 2;

		for (y = 0; y < ra->getLy(); y++)

			for (x = 0; x < ra->getLx(); x++) {

				TPixelGR8 *apix = (TPixelGR8 *)ra->getRawData(x, y);

				TPixelGR8 *bpix = (TPixelGR8 *)rb->getRawData(x, y);

				int rA = apix->value;

				int rB = bpix->value;

				if (!areAlmostEqual(double(rA), double(rB), err)) {

					cout << "MISMATCH: x=" << x << " y=" << y

						 << ". Pixel a = (" << (int)rA << ")"

						 << ". Pixel b = (" << (int)rB << ")" << endl;

					return false;

				}

			}

	} else if (raCM32) {

		TRasterCM32P rbCM32 = rb;

		if (!rbCM32)

			return 2;

		for (y = 0; y < ra->getLy(); y++)

			for (x = 0; x < ra->getLx(); x++) {

				TPixelCM32 *apix = (TPixelCM32 *)ra->getRawData(x, y);

				TPixelCM32 *bpix = (TPixelCM32 *)rb->getRawData(x, y);

				int rAink = apix->getInk();

				int rAtone = apix->getTone();

				int rAPaint = apix->getPaint();

				int rBink = bpix->getInk();

				int rBtone = bpix->getTone();

				int rBPaint = bpix->getPaint();

				if (!areAlmostEqual(double(rAink), double(rBink), err) ||

					!areAlmostEqual(double(rAtone), double(rBtone), err) ||

					!areAlmostEqual(double(rAPaint), double(rBPaint), err)) {

					cout << "MISMATCH: x=" << x << " y=" << y

						 << ". Pixel a = (Ink: " << (int)rAink << ",Tone: " << (int)rAtone << ",Paint: " << (int)rBPaint << ")"

						 << ". Pixel b = (Ink: " << (int)rBink << ",Tone: " << (int)rBtone << ",Paint: " << (int)rBPaint << ")" << endl;

					return false;

				}

			}

	} else

		return 2;

	return true;

}

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

/*!

*  Return true if \b va vector image and \b vb vector image are equal, with an

*	 error less than \b err; return false otherwise.

*  To verify vector image parity check stroke count, control point count and

*	 control point position; if vector image are different is showed an error message.

*

*  \b err max percentage variance, related to save box, allowed to control point

*					position.

*

*  OSS.: Usually \b va is check image and \b vb reference image.

*/

int areEqual(TVectorImageP va, TVectorImageP vb, double err)

{

	if (!va && !vb)

		return true;

	int aStrokeCount = va->getStrokeCount();

	int bStrokeCount = vb->getStrokeCount();

	if (aStrokeCount != bStrokeCount) {

		cout << "MISMATCH: image stroke count = " << aStrokeCount

			 << ". Reference image stroke count = " << bStrokeCount << "." << endl;

		return false;

	}

	TRectD aRect = va->getBBox();

	double lxErr = 0.00001;

	double lyErr = 0.00001;

	if (err != 0) {

		lxErr = (aRect.getLx() * err) * 0.01;

		lyErr = (aRect.getLy() * err) * 0.01;

	}

	TRectD bRect = vb->getBBox();

	if (!areAlmostEqual(bRect.getLx(), aRect.getLx(), lxErr) ||

		!areAlmostEqual(bRect.getLy(), aRect.getLy(), lyErr)) {

		cout << "MISMATCH: different save box rect." << endl;

		return false;

	}

	int i;

	for (i = 0; i < aStrokeCount; i++) {

		TStroke *aStroke = va->getStroke(i);

		TStroke *bStroke = vb->getStroke(i);

		int aStrCPCount = aStroke->getControlPointCount();

		int bStrCPCount = bStroke->getControlPointCount();

		if (aStrCPCount != bStrCPCount) {

			cout << "MISMATCH: image stroke " << i << "_mo control point count = " << aStrCPCount

				 << ". Reference image stroke " << i << "_mo control point count = " << bStrCPCount

				 << "." << endl;

			return false;

		}

		int j;

		for (j = 0; j <= aStrCPCount; j++) {

			TThickPoint aControlPoint = aStroke->getControlPoint(j);

			TThickPoint bControlPoint = bStroke->getControlPoint(j);

			if (!areAlmostEqual(aControlPoint.x, bControlPoint.x, lxErr)) {

				cout << "MISMATCH: different control point x position." << endl;

				return false;

			}

			if (!areAlmostEqual(aControlPoint.y, bControlPoint.y, lyErr)) {

				cout << "MISMATCH: different control point y position." << endl;

				return false;

			}

			if (!areAlmostEqual(aControlPoint.thick, bControlPoint.thick)) {

				cout << "MISMATCH: different control point thickness." << endl;

				return false;

			}

		}

	}

	/* Non controllo i punti di controllo!!!

	int aStrCPCount = aStroke->getControlPointCount();

	int bStrCPCount = bStroke->getControlPointCount();

	if(aStrCPCount != bStrCPCount)

	{

		cout << "MISMATCH: image stroke " << i << "_mo control point count = " << aStrCPCount

				 << ". Reference image stroke " << i << "_mo control point count = " << bStrCPCount

				 << "." << endl;

		return false;

	}

	int j;

	for(j=0; j<=aStrCPCount; j++)

	{

		TThickPoint aControlPoint = aStroke->getControlPoint(j);

		TThickPoint bControlPoint = bStroke->getControlPoint(j);

		if(!areAlmostEqual(aControlPoint.x, bControlPoint.x, lxErr))

		{

			cout << "MISMATCH: different control point x position." << endl;

			return false;

		}

		if(!areAlmostEqual(aControlPoint.y, bControlPoint.y, lyErr))

		{

			cout << "MISMATCH: different control point y position." << endl;

			return false;

		}

		if(!areAlmostEqual(aControlPoint.thick, bControlPoint.thick))

		{

			cout << "MISMATCH: different control point thickness." << endl;

			return false;

		}

	}*/

	return true;

}

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

/*!

*  Return true if images \b a and \b b are equal, with an error

*  less than \b err; return false otherwise.

*

*  If images are rasters recall

*  \b bool areEqual(TRasterP ra, TRasterP rb)

*  else if image are vectorImage recall

*  \b bool areEqual(TVectorImageP ra, TVectorImageP rb)

*/

int areEqual(TImageP a, TImageP b, double err)

{

	if (!a && !b)

		return true;

	if (!a || !b)

		return false;

	if (a->getType() != b->getType())

		return false;

	TRasterImageP ra(a);

	TRasterImageP rb(b);

	if ((!ra && rb) || (ra && !rb))

		return false;

	if (ra && rb)

		return areEqual(ra->getRaster(), rb->getRaster(), err);

	TToonzImageP ta(a);

	TToonzImageP tb(b);

	if ((!ta && tb) || (ta && !tb))

		return false;

	if (ta && tb)

		return areEqual(ta->getRaster(), tb->getRaster(), err);

	TVectorImageP va(a);

	TVectorImageP vb(b);

	if (va && vb)

		return areEqual(va, vb, err);

	return false;

}

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

bool areEqual(const TPalette *paletteA, const TPalette *paletteB)

{

	if (paletteA->getStyleCount() != paletteB->getStyleCount() ||

		paletteA->getPageCount() != paletteB->getPageCount()) {

		cout << "PALETTE style count MISMATCH" << endl;

		return false;

	}

	int i;

	for (i = 0; i < paletteA->getStyleCount(); i++) {

		TColorStyle *styleA = paletteA->getStyle(i);

		TColorStyle *styleB = paletteB->getStyle(i);

		if (styleA->getMainColor() == styleB->getMainColor())

			continue;

		cout << "PALETTE style MISMATCH" << endl;

		return false;

	}

	return true;

}

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

bool areEqual(TLevelP la, TLevelP lb)

{

	if (la->getFrameCount() != lb->getFrameCount()) {

		cout << "FRAME COUNT MISMATCH" << endl;

		return false;

	}

	if (!areEqual(la->getPalette(), lb->getPalette()))

		return false;

	TLevel::Iterator ait = la->begin(), bit = lb->begin();

	for (; ait != la->end(); ait++, bit++) {

		assert(bit != lb->end());

		if (!areEqual(ait->second, bit->second))

			return false;

	}

	return true;

}