#include <iostream>
#include <limits>
#include <signal.h>
#include <unistd.h>

#include "../shared/MiscSupport.h"
#include "../shared/SimpleLogFile.h"
#include "../shared/GlobalConfigFile.h"
#include "../shared/MarketHours.h"

#include "MainLoop.h"

static bool signalReceived = false;

static void signalHandler(int signal)
{ // Spryware needs to do its cleanup.  Most of the code is fine with being
  // terminated.
  std::cout<<"Cleaning up.  Please wait."<<std::endl;
  TclList msg;
  msg<<__FILE__<<__LINE__<<__FUNCTION__
     <<"signal"<<signal;
  sendToLogFile(msg);

  // Disable the signal handlers.  If someone hits control-C a second time,
  // assume this graceful shutdown isn't working, and just stop.
  struct sigaction onSignal;
  onSignal.sa_handler = SIG_DFL;
  sigemptyset(&onSignal.sa_mask);
  sigaction(SIGHUP, &onSignal, NULL);
  sigaction(SIGTERM, &onSignal, NULL);
  sigaction(SIGINT, &onSignal, NULL);
  signalReceived = true;
}

void MainLoop::installSignalHandlers()
{ // Use sigaction() rather than signal().  The SpryWare samples use signal().
  // But the man pages say that signal() is not well defined in a multi-
  // threaded program.
  struct sigaction onSignal;
  onSignal.sa_handler = signalHandler;
  sigemptyset(&onSignal.sa_mask);
  // Try to mask out recursive calls to the signal handle.  I'm not sure this
  // works.
  sigaddset(&onSignal.sa_mask, SIGHUP);
  sigaddset(&onSignal.sa_mask, SIGTERM);
  sigaddset(&onSignal.sa_mask, SIGINT);
  onSignal.sa_flags = 0;
  // The SpryWare samples only grab one of these.  All three seem common.  It's
  // tempting to add more.
  sigaction(SIGHUP, &onSignal, NULL);
  sigaction(SIGTERM, &onSignal, NULL);
  sigaction(SIGINT, &onSignal, NULL);
}

void MainLoop::startHardShutdown()
{
  TclList msg;
  msg<<__FILE__<<__LINE__<<__FUNCTION__<<"hard exit now";
  sendToLogFile(msg);
  scheduleSyncrhonizedShutdown();
}

time_t MainLoop::getDefaultStartTime()
{ // 4:20 am.  People want data at 4:30, but this gives us time to get 
  // started.
  return MARKET_HOURS_OPEN 
    - (2 * MARKET_HOURS_HOUR) - (10 * MARKET_HOURS_MINUTE);
}

time_t MainLoop::getDefaultEndTime()
{
  return MARKET_HOURS_CLOSE + (4 * MARKET_HOURS_HOUR);
}

void MainLoop::start()
{ // Typically you will start monitoring as soon as the program starts.  This
  // often happens as soon as the previous incarnation of the program ends,
  // so if there is a problem, we'll know immediately.  Do that after creating
  // this object, but before calling startWaiting().  The real work will
  // start much later, maybe 4:20am.  If we start too soon, we might get
  // confused by midnight and other daily reset problems.  startWaiting() will
  // wait for the appropriate time, then call start().
}

void MainLoop::requestGracefulShutdown()
{ // The default is no attempt at a graceful shutdown.  Go immeidately to a
  // hard exit.  Typically you'll replace this with a simple call to shut down
  // spryware.  We don't try to completely shut everything down.  That would
  // take too long at best.  And some of my standard library routines were
  // never made to shut down, but to run until the program exits.
  startHardShutdown();
}

MainLoop::MainLoop()
{ // We never really needed signal handlers except in the Spryware code.
  // That's long gone.  I've been ignoring this because it didn't seem to
  // hurt.  Recently we've been crashing on a broken pipe, so Sockets.C now
  // blocks with that signal.  Just to avoid any possible conflict, I've
  // removed the following code.
  //installSignalHandlers();
}

void MainLoop::startWaiting()
{
  // start_time is when we should start the alerts.  This is measured in
  // seconds after midnight, local time.  We look at end_time to determine
  // if these two times are today or tomorrow.  The idea is that you might
  // manually restart the software by running the same script that
  // automatically starts the software every day.  In that case if we start
  // the software after the alerts should be going, we start firing alerts
  // ASAP.  The other common case would be that we are starting the software
  // for tomorrow just a few minutes after the software for today shut down.
  // In that case we want to sit in test mode until we are supposed to start
  // sending alerts tomorrow.
  const time_t date = midnight(time(NULL));
  time_t startTime = 
    strtolDefault(getConfigItem("start_time"), getDefaultStartTime()) + date;

  // end_time should be the time when we automatically shut down.  This is
  // measured in seconds after midnight, local time.  If that time today is in
  // the future, then we exit at that time today.  Otherwise we exit at that
  // time tomorrow.  We don't look for odd cases, like a negative number,
  // a very large value, or start time after end time.
  time_t endTime = 
    strtolDefault(getConfigItem("end_time"), getDefaultEndTime()) + date;
  if (endTime < time(NULL))
    {
      startTime += 24 * MARKET_HOURS_HOUR;
      endTime += 24 * MARKET_HOURS_HOUR;
    }

  TclList msg;
  msg<<__FILE__<<__LINE__<<__FUNCTION__
     <<"start at"<<ctimeString(startTime)
     <<"exit at"<<ctimeString(endTime);
  sendToLogFile(msg);

  while (true)
    {
      const time_t now = time(NULL);
      if ((now >= endTime) || signalReceived)
	// Note:  It could take us up to 1 second to deal with a signal.  But
	// since the cleanup routine takes several seconds, that shouldn't
	// matter.  In reality it could take much longer.  Since we're trying
	// to insert something into the data node thead, we have to wait for
	// whatever's going on in there.  If something's locked up, we can't
	// do a graceful shutdown.  If we're in the process of a normal start,
	// it could take a while to get to this message.  Also, there's a known
	// issue in SpryWare, and if we try to shut down the PricePlus table
	// before it has finished initializing, things will lock up.
	break;
      if (now > startTime)
	{ // Start full alerts.
	  start();
	  // Don't call this again!
	  startTime = std::numeric_limits< time_t >::max();
	}
      sleep(1);
    }
  msg.clear();
  msg<<__FILE__<<__LINE__<<__FUNCTION__
     <<"exiting now";
  sendToLogFile(msg);
  requestGracefulShutdown();

  // Graceful exit hangs a lot!  Wait three minutes before trying a hard exit.
  // Hard exit always works, as long as someone else does the clean up before
  // trying to start again.  Leaving these things running for more than a day
  // would probably be a bad idea.  I chose 20 minutes because Curtiss from
  // SpryWare said that sometimes it takes 15 minutes to shut down.  He said
  // that's part of a bug that he hopes to fix soon.  (Info received
  // 11/20/2009)  It takes only a few seconds when it works correctly.
  endTime = time(NULL) + 20 * MARKET_HOURS_MINUTE;

  // Wait for the graceful shutdown, including waiting for the log file to
  // process that last message.  Then someone will call exit().
  // Even if we weren't deferring to another thread, we'd still call exit()
  // rather than just falling through the bottom of main().
  // Some of these local objects don't shut down very well.  It's better to
  // call exit() than to just fall through.  Also, this only works because
  // the SpryWare code is doing it's cleanup.  If you comment that code out,
  // and try to fall through the end of main(), things will fail badly.
  while (time(NULL) < endTime)
    sleep(1);

  msg.clear();
  msg<<__FILE__<<__LINE__<<__FUNCTION__
     <<"hard exit now"<<"graceful exit timed out";
  sendToLogFile(msg);
  startHardShutdown();
  startHardShutdown();

  // Again, we can't fall through.  That would cause errors and our log file
  // would not be right.
  while (true)
    sleep(10000);
}