/**
   @file        SOFIELeve1.cpp

   @brief Top level routine for the SOFIE Level 1 Processing System
   Uses 4 Event objects as the primary container for data flowing 
   through the processing system

   @author John Burton <j.c.burton@gats-inc.com>

   @date  Fri Apr 14 17:03:48 2006

   @copyright
   (&copy;) Copyright 2006 by GATS, Inc.,
   11864 Canon Blvd, Suite 101, Newport News VA 23606

   All Rights Reserved. No part of this software or publication may be
   reproduced, stored in a retrieval system, or transmitted, in any form
   or by any means, electronic, mechanical, photocopying, recording, or
   otherwise without the prior written permission of GATS, Inc.

*/
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//

#include <unistd.h>
#include "Event.h"
#include "ConfigFile.h"
#include "SOFIELevel1.h"
#include "GATS_Utilities.hpp"
#include <vector>

//
//-----------------------------------------------------------------------
// Defines and Macros:
//-----------------------------------------------------------------------
//
using namespace std;


//
//-----------------------------------------------------------------------
// Global Variables:
//-----------------------------------------------------------------------
//

map<string,funcptr> ExecMap;


//
//-----------------------------------------------------------------------
// Utility Routines:
//-----------------------------------------------------------------------
//

///
/// plotEventVars displays set of EventVars selected from the Event object
/// \c ev using the EventVar \c Plot method. The set of EventVars is 
/// specified by the list of variable names contained in the vector of 
/// strings \c plotlist.
/// @param ev - the Event object containing the EventVars to be plotted
/// @param plotlist - the list of EventVar names to be plotted
/// @param fname - a string to be passed to the EventVar \c Plot method
///   title parameter.
///
int plotEventVars(Event &ev, vector<string> plotlist, string fname)
{
  int i,j,typ;
  string vname;
  EventVarVect<int>    iEVV;
  EventVarVect<float>  fEVV;
  EventVarVect<double> dEVV;

  for(i=0; i<plotlist.size(); i++)
  {
    vname = plotlist[i];
    typ = ev.EventVarExists(vname);
//    cerr << "Plotting EventVar: " << vname << "type = " << typ << " ";
    switch(typ)
    {
    case 0:
//      cerr<<"EventVar " << vname << " does not exist\n";
      break;
    case 1:
      ev.getEventVar(vname,iEVV);
      iEVV.Plot(fname,vname);
//      for(j=0;j<iEVV.size();j++)
//	iEVV[j].Plot(fname,vname);
      iEVV.clear();
      break;
    case 2:
      ev.getEventVar(vname,fEVV);
      fEVV.Plot(fname,vname);
//      for(j=0;j<fEVV.size();j++)
//	fEVV[j].Plot(fname,vname);
      fEVV.clear();
      break;
    case 3:
      ev.getEventVar(vname,dEVV);
      dEVV.Plot(fname,vname);
//      for(j=0;j<dEVV.size();j++)
//	dEVV[j].Plot(fname,vname);
      dEVV.clear();
      break;
    }    
  }
}

///
/// processEvent is the primary routine for processing Level 0 data into
/// Level 1 data. The actual processing is controlled by the list of modules
/// provided by the \c ExecList variable of the \C SOFIELevel1 section of the 
/// main configuration file. 
/// @param L0 - the Event object containing the Level 0 data
/// @param L1 - the Event object that will contain the Level 1 data after processing
///             is complete
/// @param tmp - the Event object that contains intermediate, temporary data
/// @param SD - the Event object containing static data, that is data that is constant
///             from one event to the next, i.e. calibration data.
/// @param cf - the ConfigFile object for the top levvel configuration file.
///
int ProcessEvent(Event &L0, Event &L1, Event &tmp, Event& SD, ConfigFile &cf)
{
  map<string,funcptr>::iterator iter; // iterator to find a given function in the map
  vector<string> ExecList;            // List of modules to be executed to process an Event
  vector<string> PlotList;            // List of EventVars to be plotted  
  int            i;                   // index into the ExecList string vector 
  int            ret;                 // value returned by the executable module
  funcptr        func;                // function pointer to the executable module
  string         fname;               // name of the currently executing function
  string         logentry;            // log entry
//
// Open log file in Level 1 Event Object and timestamp entries
//
  L1.openEventLog("SOFIELevel1Processing.log");
  L1.enableLogTimeStamp();

  logentry = string("Processing Event: ") + 
  		GATS_Utilities::ConvertToString(L0.getEventNumber());
  cerr << endl;
  cerr << logentry << endl;
  cerr << endl;
  L1.addLogEntry(logentry);

//   logentry = string("Sunset/Sunrise flag: ") + 
//   		GATS_Utilities::ConvertToString(L0.getSRSSFlag());
//   cerr << logentry << endl;
//   L1.addLogEntry(logentry);

//
// Get and step through ExecList
//
  ExecList  = cf.GetStrValues("SOFIELevel1","ExecList");
  for(i=0;i<ExecList.size();i++)
  {
    fname = ExecList[i];
    iter = ExecMap.find(fname);
    if (iter == ExecMap.end())
    {
      logentry = "Undefined reference to: " +  fname;
      L1.addLogEntry(logentry);
    }
    else
    {
      logentry = "Processing " + fname;
      L1.addLogEntry(logentry);
      cerr << endl;
      cerr << logentry << endl;

      func = (*iter).second;
      if(ret = func(L0,L1,tmp,SD,cf) )
	{
	logentry = "Problems processing last module.  Skipping to next event"; 
	L1.addLogEntry(logentry);
	cerr << logentry << endl;
	break;
	}      	
    }
    if(cf.ValidEntry(fname,"PlotLevel0Data"))
    {
      PlotList = cf.GetStrValues(fname,"PlotLevel0Data");
      plotEventVars(L0,PlotList,fname);
    }
    if(cf.ValidEntry(fname,"PlotLevel1Data"))
    {
      PlotList = cf.GetStrValues(fname,"PlotLevel1Data");
      plotEventVars(L1,PlotList,fname);
    }
    if(cf.ValidEntry(fname,"PlotTempData"))
    {
      PlotList = cf.GetStrValues(fname,"PlotTempData");
      plotEventVars(tmp,PlotList,fname);
    }
  }
  cerr << "Finished processing ExecList\n";
  
  L1.closeEventLog();
}


///
/// main routine for processing SOFIE Level 1 Data
///
int main(int argc, char *argv[])
{
  Event          Level0Event;    // Event object containing the Level 0 EventVars 
  Event          Level1Event;    // Event object containing the Level 1 EventVars 
  Event          Temp;           // Event object containing the temporary EventVars
  Event          StaticData;     // Event object containing the static / permanent EventVars
  ConfigFile     cf;             // Top level ConfigFile object containing configuration data
  int            i;              // Loop counter for initializing ExecMap
  int            j;              // Loop counter to step through EventList
  int            ret;            // Return value from call to initialize
  vector<int>    EventList;      // List of events to process (from configuration file
  string         fname;          // Filename of the top level configuration file

//
// Check command line options
//
  int          c;                  // inidividual command line argument
  extern char *optarg;             // List of command line arguments
  extern int optind,opterr,optopt; // Index into the list of command line arguments

  while((c = getopt(argc,argv,"A:a:E:e:f:m:n:T:t:rj")) != EOF)
    switch(c)
    {
    default:
      break;
    }
  if(optind < argc)
    fname = string(argv[optind]);
  else
    fname = "SOFIELevel1.ini";

//
// Open and parse the top level configuration file
//
  cf.open(fname);
 
//
// Initialize ExecMap - map of names vs. pointers to functions
//
  for(i=0;i<n_execs;i++)
    ExecMap[execs[i].name] = execs[i].ptr;

//
// Perform any per run initialization (read calibration data?)
//
  ret = Initialize(Level0Event,Level1Event,Temp,StaticData,cf);
  
//
// Get and step through the EventList
//
  EventList = cf.GetIntValues("SOFIELevel1","EventList");
  for(j=0;j<EventList.size();j++)
  {
    InitializeEvent(Level0Event,Level1Event,Temp,StaticData,cf);
    Level0Event.setEventNumber(EventList[j]);
    ProcessEvent(Level0Event,Level1Event,Temp,StaticData,cf);
  }
  
  
  return 0;
}