#include <iostream>
#include <limits>

#include "../shared/MiscSupport.h"
#include "../shared/GlobalConfigFile.h"
#include "GridFiller.h"
#include "TclObjHolder.h"

class FakeDataProvider : public GridDataProvider
{
public:
  bool getValid(GridDataProviderContext *context) const { return true; }
  double getValue(std::string const &dataType, 
		  GridDataProviderContext *context,
		  int offset,
		  std::string &errorMsg) const
  {
    errorMsg.clear();
    if (dataType == "error")
      // A data error.  Like no trades during this period.
      // These are unavaidable.
      return GridInstance::invalid();
    else if (dataType == "error_msg")
    { // A syntax error.  Like current("hihg").
      // We should print an error message.
      errorMsg = "This is an error.";
      return GridInstance::invalid();
    }
    else if (dataType == "packed row")
      return context->getCalculationRowPacked() - offset;
    else if (dataType == "possible row")
      return context->getCalculationRowPossible(offset);
    else if (dataType == "min")
      return -std::numeric_limits< double >::max();
    else if (dataType == "max")
      return std::numeric_limits< double >::max();
    else if (dataType == "start")
      {
	time_t start;
	time_t end;
	context->getPrototype()->getCandleTimer()
	  ->getTimes(context->getCalculationRowPossible(offset), start, end);
	return start;
      }
    else if (dataType == "end")
      {
	time_t start;
	time_t end;
	context->getPrototype()->getCandleTimer()
	  ->getTimes(context->getCalculationRowPossible(offset), start, end);
	return end;
      }
    else
      return dataType.size();
  }
  time_t restartAt(EpochCounter::Epoch epoch) const { return 0; }
  std::string debugDump() const { return "fake data"; }
};

static GridPrototypeRef getTestPrototype()
{
  GridPrototype *result = 
    new GridPrototype(2, 11, SimpleCandleTimer::Round(), true);
  result->setColumnName("Counter", 0);
  result->setColumnName("Sum False", 1);
  result->setColumnName("Sum True", 2);
  result->setColumnName("Count", 3);
  result->setColumnName("Average False", 4);
  result->setColumnName("Average True", 5);
  result->setColumnName("Max False", 6);
  result->setColumnName("Max True", 7);
  result->setColumnName("Min False", 8);
  result->setColumnName("Min True", 9);
  result->setColumnName("Fib", 10);
  result->setFormula(0, "Counter", "0");
  result->setFormula(1, "Counter", "ref(-1, \"Counter\") + 1");
  result->setFormulaDown(0, "Sum False", "sum(-2, 0, \"Counter\", 0)");
  result->setFormulaDown(0, "Sum True", "sum(-2, 0, \"Counter\", 1)");
  result->setFormulaDown(0, "Count", "count(-2, 0, \"Counter\")");
  result->setFormulaDown(0, "Average False", "average(-2, 0, \"Counter\", 0)");
  result->setFormulaDown(0, "Average True", "average(-2, 0, \"Counter\", 1)");
  result->setFormulaDown(0, "Max False", "max(-2, 0, \"Counter\", 0)");
  result->setFormulaDown(0, "Max True", "max(-2, 0, \"Counter\", 1)");
  result->setFormulaDown(0, "Min False", "min(-2, 0, \"Counter\", 0)");
  result->setFormulaDown(0, "Min True", "min(-2, 0, \"Counter\", 1)");
  result->setFormula(0, "Fib", "1");
  result->setFormula(1, "Fib", "sum(-2, -1, \"Fib\", 1)");
  return result;
}

void testNan(Tcl_Interp *interp, std::string toCompute)
{
  std::cout<<"testNan(“"<<toCompute<<"”)"<<std::endl;
  TclObjHolder input = GridFiller::makeString(toCompute);
  Tcl_Obj *outputTemp;
  TclObjHolder output;
  int result = Tcl_ExprObj(interp, input.getObj(), &outputTemp);
  if (result == TCL_OK)
  {
    output = outputTemp;
    std::cout<<"TCL_OK:  "<<GridFiller::getString(output.getObj())<<std::endl;
  }
  else
  {
    std::cout<<"TCL_ERROR:  "<<GridFiller::getString(Tcl_GetObjResult(interp))
	     <<std::endl;
  }
}

static void simpleTest()
{
  GridFiller gridFiller;
  testNan(gridFiller.debugGetInterp(), "Ye");
  testNan(gridFiller.debugGetInterp(), "5*5");
  testNan(gridFiller.debugGetInterp(), "5/0.0");
  testNan(gridFiller.debugGetInterp(), "5/0");
  testNan(gridFiller.debugGetInterp(), "0.0/0.0");
  testNan(gridFiller.debugGetInterp(), "sqrt(0)");
  testNan(gridFiller.debugGetInterp(), "sqrt(-1)");
  GridInstance *grid = new GridInstance(getTestPrototype(), 
					new FakeDataProvider);
  while (std::cin)
    {
      char buffer[100];
      std::cout<<"more?  ";
      std::cin.getline(buffer, 99);
      std::string input(buffer);
      if (input == "c")
	{
	  std::cout<<"One cell!"<<std::endl;
	  gridFiller.fillCell(grid);
	}
      else if (input == "r")
	{
	  std::cout<<"One row!"<<std::endl;
	  gridFiller.fillRow(grid);
	}
      else if (input == "e")
	{
	  std::cout<<"execute? ";
	  std::cin.getline(buffer, 99);
	  Tcl_Interp *interp = gridFiller.debugGetInterp();
	  const int result = Tcl_Eval(interp, buffer);
	  std::cout<<result<<":  "<<Tcl_GetStringResult(interp)<<std::endl;
	}
      else if (input == "time")
	{
	  const int count = 1000;
	  TimeVal start(true);
	  for (int i = 0; i < count; i++)
	    gridFiller.fillRow(grid);
	  TimeVal end(true);
	  std::cout<<(end.asMicroseconds() - start.asMicroseconds())
		   <<"µs, count = "
		   <<count
		   <<std::endl;
	}
      else if (input == "dd")
	{
	  std::cout<<grid->getPrototype()->debugDump()<<std::endl;
	  std::cout<<grid->debugDump()<<std::endl;
	}
      else if (!std::cin)
	{
	  break;
	}
      else
	{
	  std::cout<<"c = cell, r = row, e = execute, time, dd = debug dump."<<std::endl;
	}
    }
  delete grid;
}

void testMem()
{
  std::cout<<"sizeof(void *) = "<<sizeof(void *)<<std::endl;
  std::cout<<"sizeof(size_t) = "<<sizeof(size_t)<<std::endl;
  void *a = fixedMalloc(1);
  void *b = fixedMalloc(1);
  void *c = fixedMalloc(1);
  std::cout<<"a: "<<a<<std::endl;
  std::cout<<"b: "<<b<<std::endl;
  std::cout<<"c: "<<c<<std::endl;
  fixedFree(a);
  fixedFree(b);
  fixedFree(c);
  a = fixedMalloc(1);
  b = fixedMalloc(1);
  c = fixedMalloc(1);
  std::cout<<"a: "<<a<<std::endl;
  std::cout<<"b: "<<b<<std::endl;
  std::cout<<"c: "<<c<<std::endl;
  fixedFree(a);
  fixedFree(b);
  fixedFree(c);
  a = fixedMalloc(7);
  b = fixedMalloc(7);
  c = fixedMalloc(7);
  std::cout<<"a: "<<a<<std::endl;
  std::cout<<"b: "<<b<<std::endl;
  std::cout<<"c: "<<c<<std::endl;
  fixedFree(a);
  fixedFree(b);
  fixedFree(c);
  a = fixedMalloc(8);
  b = fixedMalloc(8);
  c = fixedMalloc(8);
  std::cout<<"a: "<<a<<std::endl;
  std::cout<<"b: "<<b<<std::endl;
  std::cout<<"c: "<<c<<std::endl;
  fixedFree(a);
  fixedFree(b);
  fixedFree(c);
  a = fixedMalloc(9);
  b = fixedMalloc(9);
  c = fixedMalloc(9);
  std::cout<<"a: "<<a<<std::endl;
  std::cout<<"b: "<<b<<std::endl;
  std::cout<<"c: "<<c<<std::endl;
  struct front 
  {
    int32_t a;
    int64_t b;
    int64_t c;
  };
  struct middle
  {
    int64_t b;
    int32_t a;
    int64_t c;
  };
  struct end
  {
    int64_t b;
    int64_t c;
    int32_t a;
  };
  struct only
  {
    int32_t a;
  };
  std::cout<<"front:  "<<sizeof(front)
	   <<", middle:  "<<sizeof(middle)
	   <<", end:  "<<sizeof(end)
	   <<", only:  "<<sizeof(only)<<std::endl;
}

int main(int argc, char **argv)
{
  setlocale(LC_ALL, "");
  //mySqlInit();

  if (!addConfigItemsFromCommandLine(argv + 1))
    {
      return 1;
    }
  configItemsComplete();

  testMem();

  simpleTest();

  return 0;
}