#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>

#include <sstream></sstream>

#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))) {

    std::istringstream 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;

}