#include <iostream>
#include <limits>
#include <tcl.h>

#include "../shared/CommandDispatcher.h"
#include "../shared/NewConnections.h"
#include "../shared/InputFramework.h"
#include "../shared/GlobalConfigFile.h"
#include "../shared/ReplyToClient.h"
#include "../shared/Ping.h"
#include "../shared/SimpleLogFile.h"
#include "../shared/MarketHours.h"
#include "GridFiller.h"
#include "DataNodeThread.h"
#include "ScriptDispatcher.h"
#include "UserInfo.h"
#include "ReportAlertsThread.h"
#include "CandleServer.h"
#include "LimitAlert.h"


static GridPrototypeRef getTestPrototype()
{
  GridPrototype *result = new GridPrototype(2, 8, SimpleCandleTimer::Today(), true);
  result->setColumnName("Counter", 0);
  result->setColumnName("Open", 1);
  result->setColumnName("High", 2);
  result->setColumnName("Low", 3);
  result->setColumnName("Close", 4);
  result->setColumnName("Average False", 5);
  result->setColumnName("Average True", 6);
  result->setColumnName("Fib", 7);
  result->setFormula(0, "Counter", "0");
  result->setFormula(1, "Counter", "ref(-1, \"Counter\") + 1");
  result->setFormulaDown(0, "Open", "current(\"open\")");
  result->setFormulaDown(0, "High", "current(\"high\")");
  result->setFormulaDown(0, "Low", "current(\"low\")");
  result->setFormulaDown(0, "Close", "current(\"close\")");
  result->setFormulaDown(0, "Average False", "average(-4, 0, \"Close\", 0)");
  result->setFormulaDown(0, "Average True", "average(-4, 0, \"Close\", 1)");
  result->setFormula(0, "Fib", "1");
  result->setFormula(1, "Fib", "sum(-2, -1, \"Fib\", 1)");
  return result;
}

static void tclOneTimeInit()
{ // According to some sources, you should call this once before anything
  // else when trying to run TCL in multi-threaded environment.  I've
  // recompiled the TCL libraries with multi-threading enabled, but that is
  // not sufficient.
  //
  // http://stackoverflow.com/questions/19164452/use-of-tcl-in-c-multithreaded-application
  //
  // I sometimes see a core dump.  It only happens when we first start.  This
  // is where I was the last time:
  // 
// Core was generated by `./tikiller-tiq -i database_candles=its-the-cops -i database_RW=roberto -i init_'.
// Program terminated with signal 11, Segmentation fault.
// #0  0x0000000000000000 in ?? ()
// Missing separate debuginfos, use: debuginfo-install glibc-2.17-20.fc19.x86_64 keyutils-libs-1.5.9-1.fc19.x86_64 krb5-libs-1.11.3-21.fc19.x86_64 libcom_err-1.42.7-2.fc19.x86_64 libgcc-4.8.2-7.fc19.x86_64 libselinux-2.1.13-15.fc19.x86_64 libstdc++-4.8.2-7.fc19.x86_64 libuuid-2.23.2-5.fc19.x86_64 mariadb-libs-5.5.37-1.fc19.x86_64 openssl-libs-1.0.1e-38.fc19.x86_64 pcre-8.32-9.fc19.x86_64 zlib-1.2.7-10.fc19.x86_64
// (gdb) bt
// #0  0x0000000000000000 in ?? ()
// #1  0x00007f0db96a022b in ThreadStorageGetHashTable (id=0x7f0da67fc700)
//     at /root/rpmbuild/BUILD/tcl8.5.14/unix/../generic/tclThreadStorage.c:230
// #2  0x00007f0db96a0331 in TclpThreadDataKeyGet (
//     keyPtr=keyPtr@entry=0x7f0db98fbe78 <dataKey>)
//     at /root/rpmbuild/BUILD/tcl8.5.14/unix/../generic/tclThreadStorage.c:357
// #3  0x00007f0db969f1ef in Tcl_GetThreadData (
//     keyPtr=keyPtr@entry=0x7f0db98fbe78 <dataKey>, size=size@entry=104)
//     at /root/rpmbuild/BUILD/tcl8.5.14/unix/../generic/tclThread.c:85
// #4  0x00007f0db9682809 in TclInitNotifier ()
//     at /root/rpmbuild/BUILD/tcl8.5.14/unix/../generic/tclNotify.c:127
// #5  0x00007f0db960c333 in Tcl_CreateInterp ()
//     at /root/rpmbuild/BUILD/tcl8.5.14/unix/../generic/tclBasic.c:401
// #6  0x00000000004a6c05 in GridFiller::initInterp (this=0x1481470)
//     at GridFiller.C:365
// #7  0x0000000000488fc9 in debugGetInterp (this=0x1481470) at GridFiller.h:109
// #8  GridWorkerThread::threadFunction (this=0x14813b0) at GridWorkerThread.C:59
// #9  0x0000000000422adc in ThreadClass::threadAdapter (me=0x14813b0)
//     at ../shared/ThreadClass.C:33
// #10 0x00007f0dba21bc53 in start_thread () from /lib64/libpthread.so.0
// #11 0x00007f0db8af2dbd in clone () from /lib64/libc.so.6
// (gdb) 
//
// The log file suggested that two different instances of GridWorkerThread had
// both started. 
//
// I've had similar issues in the past.  Once in a while I get a core dump,
// always when I'm initializing.
  Tcl_FindExecutable(NULL);
}

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

  tclOneTimeInit();

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

  //initializeSimpleMarketData();
  //initializeShortTermCandles();
  initPing();

  DataNodeThread dataNodeThread;

  initReplyToClient();
  UserInfoThread::init();
  CommandDispatcher *commandDispatcher = CommandDispatcher::getInstance();
  commandDispatcher->requireLogin();
  InputListener listener(commandDispatcher->getInput(),
                         commandDispatcher->getInputCallbackId());
  const int listenPort =
    strtolDefault(getConfigItem("listen_port", "9369"), -1);
  if (listenPort <= 0)
    {
      std::cerr<<"Invalid listen port \""
               <<getConfigItem("listen_port")<<"\"\n";
      _exit(2);
    }

  ReportAlertsThread reportAlertsThread;

  LimitAlertManager::primary =
    new LimitAlertManager(&dataNodeThread.getDataNodeManager());
  
  ScriptDispatcher::init(dataNodeThread);
  initCandleServer(&dataNodeThread);
  NewConnections newConnections(&listener, listenPort);
  if (!newConnections.getSuccess())
  {
    std::cerr<<"Unable to listen for new connections.\n";
    _exit(3);
  }

  sleep(2);
  GridPrototypeRef prototype = getTestPrototype();
  /*
  dispatcher.start("DELL", prototype);
  sleep(2);
  dispatcher.start("MSFT", prototype);
  sleep(2);
  dispatcher.start("ORCL", prototype);
  sleep(2);
  dispatcher.start("INTC", prototype);
  sleep(2);
  dispatcher.start("IBM", prototype);
  sleep(2);
  dispatcher.start("T", prototype);
  */

  // We end the program when the time (i.e. the number of seconds after 
  // midnight) crosses this value.  We're only precise to the minute.
  // A value of 0 or less or blank means never shut down.
  // When we act more like TIQ, presenting well known strategies to the user,
  // It makes sense to shut down and restart once a day automatically.  When
  // we allow custom formulas from the user, it makes more sense to stay 
  // available 24/7.
  // Note that you have to cross the threshold to quit.  So if the
  // shutdown time is 5pm, and you start the program at 6pm, you won't
  // instantly shut down.  You will wait until 5pm the next day.
  const int endTime = strtolDefault(getConfigItem("end_time"), -1);

  // This loop replaces ../generate_alerts/MainLoop.h which is used in some
  // similar programs.  This is simpler because it doesn't have a start time
  // and it doesn't listen for signals.  Signals were only important in
  // spryware and could be removed from the other code.  Start time isn't
  // explicitly needed because everything works off of candle timers.

  time_t endTimeT;
  if (endTime <= 0)
  {
    endTimeT = std::numeric_limits< time_t >::max();
    sendToLogFile(TclList()<<FLF<<"Run forever"<<endTimeT);
  }
  else
  {
    const time_t now = time(NULL);
    endTimeT = midnight(now) + endTime;
    const bool tomorrow = endTimeT <= now;
    if (tomorrow)
      endTimeT += 24 * MARKET_HOURS_HOUR;
    sendToLogFile(TclList()<<FLF<<"Run until"<<ctimeString(endTimeT)<<"endTimeT"<<endTimeT<<"end_time"<<endTime<<(tomorrow?"tomorrow":"today"));
  }
  while (true)
  {
    sleep(60);
    if (time(NULL) >= endTimeT)
    {
      TclList msg;
      msg<<FLF<<"graceful shutdown"
	 <<"end time"<<endTime<<ctimeString(endTimeT);
      sendToLogFile(msg);
      scheduleSyncrhonizedShutdown();
    }
  }
}