#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>
#include <sstream>
 
#if defined(LINUX)
#include <typeinfo>
#endif
 
using namespace std;
 
namespace {
 
class TTestTable {
  typedef map<std::string, TTest *> Table;
  typedef set<std::string> SkipTable;
  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;
  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;
}