/****************************************************************************/
/* Copyright (c) MIT Sea Grant                                              */
/* MIT Sea Grant Proprietary Information. All rights reserved.              */
/****************************************************************************/
/* Summary  :                                                               */
/* Filename : ScheduleServer                                                */
/* Author   : Don Eickstedt                                                 */
/* Project  :                                                               */
/* Version  : 1.0                                                           */
/* Created  : 06/06/2000                                                    */
/* Modified :                                                               */
/* Archived :                                                               */
/****************************************************************************/
/* Modification History:                                                    */
/****************************************************************************/

#include "ScheduleServer.h"
#include "Syslog.h"
#include <time.h>

ScheduleServer::ScheduleServer(int millisec, Boolean test ):
  PeriodicTask("scheduleServer")
{

  //  _uam = 0;
  _lbl = 0;
  _LayeredCtl = 0;

  addPeriodicCallback(millisec, (CallbackMethod )ScheduleServer::callback);
  //
  // If Supervisor is starting this, then create an interface to Layered
  // Control.  Otherwise, this is being called by lblTest, and L. C. isn't 
  // running.
  //
  if( !test )
  {
    try
      {
	_LayeredCtl = new LayeredControlIF("layeredControl");
      }
    catch (...)
      {
	throw("Schedule Server Could not create Layered Control interface"
	      "-- aborting");
      }
  }
#if 0

  try
  {
    _uam = new ModemIF("modem");
  }
  catch (...)
  {
    throw("Could not create modem interface -- aborting");
  }

#endif

  try
  {
    _lbl = new LblIF("lblServer");
  }
  catch (...)
  {
    throw("Could not create LBL interface -- aborting");
  }

  ping_start = 0.0;
  ping_interval = 10.0-(millisec/1000.0);
  modem_start = 5.0;
  modem_interval = 10.0-(millisec/1000.0);
  modem_time = 0.0;
  ping_time = 0.0;
  modem_started = False;
  ping_started = False;
  mission_running = False;

  if( test )
  {
    //
    // Hardcode the mission initiation.
    //
    ScheduleServer::missionStartCallback(NULL, 0);
    Syslog::write("Schedule Server : Test Mode\n");
  }
  else
  {
    //
    // Subscribe to LayeredControl "MissionStarted" event
    //
    _eventService->subscribe(_LayeredCtl, LayeredControlIF::MissionStarted,
			     (EventService::Callback )
			     ScheduleServer::missionStartCallback);

    _eventService->subscribe(_LayeredCtl, LayeredControlIF::MissionStatusChange,
			     (EventService::Callback )
			     ScheduleServer::missionStopCallback);
    Syslog::write("Schedule Server : Subscribing to Layered Control.\n");
  }
}

ScheduleServer::~ScheduleServer()
{
  //delete _uam;
delete _lbl;
delete _LayeredCtl;
}

void ScheduleServer::callback()
{
  struct timespec now;
  double t_clock;
  long result2;
  long result;
  char out[100];

  clock_gettime(CLOCK_REALTIME,&now);
  t_clock = (now.tv_sec + ((double) now.tv_nsec)/1000000000L);


if (mission_running)
  {

    if (t_clock >= (ref_time + ping_start))
      if ((t_clock-ping_time) >= ping_interval)
      {
       ping_time = t_clock;
       result = _lbl->ping();
      }
#if 0
    if (t_clock >= (ref_time + modem_start))
      if ((t_clock-modem_time) >= modem_interval)
      {
      modem_time = t_clock;
      //result2 = _uam->send_telem();
      }
#endif
  }
}



void ScheduleServer::missionStartCallback(TaskInterface *taskInterface,
                                          EventCode code)
{
  struct timespec now;

  clock_gettime(CLOCK_REALTIME,&now);

  Syslog::write("Schedule Server -> Start");

  ref_time = (now.tv_sec + ((double) now.tv_nsec)/1000000000L);

  mission_running = True;
}

void ScheduleServer::missionStopCallback(TaskInterface *taskInterface,
                                          EventCode code)
{
  Syslog::write("Schedule Server -> Stop");
  mission_running = False;
}