// ProduceRunTableProc.cc
// Contact person: Javier Caravaca <jcaravaca@berkeley.edu>
// See ProduceRunTableProc.hh for more details.
//------------------------------------------------------------//

#include <RAT/ProduceRunTableProc.hh>
#include <RAT/MetaInformation.hh>
#include <RAT/Log.hh>
#include <RAT/DB.hh>
#include <RAT/DS/Entry.hh>
#include <RAT/DS/Run.hh>
using namespace RAT;

#include <stdio.h>
#include <string>
#include <sstream>
#include <libpq-fe.h>

ProduceRunTableProc::ProduceRunTableProc() : Processor("ProduceRunTableProc")
{

  fRunNumber = -1;
  fRunTypeWord = -1;
  fFirstValidGTID = -1;
  fRunTableName = "";
  setInvalidTimes();

}


void ProduceRunTableProc::SetS( const std::string& param, const std::string& value )
{

  /* Store processed zdab file names in a vector */
  if( param == "zdabs" ){
    //Breakdown string in chunks
    std::istringstream iss(value);
    copy(std::istream_iterator<string>(iss),
         std::istream_iterator<string>(),
         std::back_inserter(fZdabFilenames));
  }
  else
    throw ParamUnknown( param );
}

void ProduceRunTableProc::BeginOfRun( DS::Run& run )
{

  /* Collect run information */
  fRunNumber = run.GetRunID();
  fRunTypeWord = run.GetRunType();
  getRunTypeAndLengthFromDetectorDB();
  if(fRunTypeWord != fRunTypeWordDB){
    warn << " Run type words are different!: DS="<<fRunTypeWord<<", DB:"<<fRunTypeWordDB<<newline;
    warn << " This is a major DAQ problem. Need to be looked into. RUN table won't be produced!" << newline;
    exit(1);
  }

  fFirstValidGTID = run.GetValidGTID();
  std::stringstream stream;
  stream<<"RUN_"<<fRunNumber<<".ratdb";
  fRunTableName = stream.str();

}

Processor::Result ProduceRunTableProc::DSEvent( DS::Run& run, DS::Entry& ds )
{
  /* Gather time information from first and last valid events */

  // If it's the first Valid GTID, store its time!
  if (ds.GetEV(0).GetGTID() == fFirstValidGTID) {
    fStart_times[0] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetDays());
    fStart_times[1] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetSeconds());
    fStart_times[2] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetNanoSeconds());
  }

  // Store time of the last non-orphan event
  // Assumes that the events are sorted by timing!
  if (ds.GetEV(0).GetTrigType() != 0) { // it's NOT an orphan
    fStop_times[0] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetDays());
    fStop_times[1] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetSeconds());
    fStop_times[2] = static_cast<double>(ds.GetEV(0).GetUniversalTime().GetNanoSeconds());
  }

  return Processor::OK;
}

void ProduceRunTableProc::EndOfRun( DS::Run& run )
{

  /* Compute run duration */
  fRunLength =
    (fStop_times[0] - fStart_times[0])*60*60*24 +  // days
    (fStop_times[1] - fStart_times[1]) +           // secs
    (fStop_times[2] - fStart_times[2])*1e-9;       // nsecs

  
  printSummary();

  /* Check that the event time are OK and the
   * run duration makes sense */
  checkTimes();

  /* Create and upload RUN table */
  RAT::DBTable *RUN_table = new DBTable("RUN");
  RUN_table->SetRunRange(fRunNumber,fRunNumber);
  RUN_table->SetPassNumber(-1);
  RUN_table->SetS("index","");
  RUN_table->SetI("version",3);
  RUN_table->SetI("runtype",fRunTypeWord);
  RUN_table->SetI("start_day",fStart_times[0]);
  RUN_table->SetI("start_sec",fStart_times[1]);
  RUN_table->SetD("start_nsc",fStart_times[2]);
  RUN_table->SetI("stop_day",fStop_times[0]);
  RUN_table->SetI("stop_sec",fStop_times[1]);
  RUN_table->SetD("stop_nsc",fStop_times[2]);
  RUN_table->SetSArray("subfile_list",fZdabFilenames);

  // Save locally just in case
  RUN_table->SaveAs(fRunTableName);
  info<<" ProduceRunTableProc: RUN_table saved as: "<<fRunTableName<<newline;

  //Upload to RATDB
  if(fRunTypeWord > 0){
    try{
      DB::Get()->SetServer("postgres://ratdbwriter@pgsql.snopl.us:5400/ratdb");
      DB::Get()->UploadTableOnline(*RUN_table);
    } catch(...){
      warn << "ProduceRunTableProc::EndOfRun: RATDB upload failed. " << newline;
    }
  }
  else{
    warn << "ProduceRunTableProc::EndOfRun: Invalid RunType: " <<fRunTypeWord<<". RUN table will not upload. " << newline;
  }

}

void ProduceRunTableProc::getRunTypeAndLengthFromDetectorDB(){

  fRunTypeWordDB = -1;
  fRunLengthDB = -1;
  PGconn *detectorDB = PQconnectdb("host=pgsql.snopl.us "
                                   "port=5400 dbname=detector "
                                   "user=snoplus "
                                   "connect_timeout=15 ");

  if (PQstatus(detectorDB) == CONNECTION_BAD) {
    warn<< " ProduceRunTableProc: Connection to database failed. Error: "<< PQerrorMessage(detectorDB) << newline;
    return;
  }

  // Get run type
  char query[256];
  sprintf(query, "SELECT run_type FROM run_state WHERE run = %d", fRunNumber);
  PGresult *qResult = PQexec(detectorDB, query);
  if (PQresultStatus(qResult) != PGRES_TUPLES_OK){
    warn<< " Query to DetectorDB failed. " << newline;
  }

  if(PQntuples(qResult)>0){
    fRunTypeWordDB = atoi( PQgetvalue(qResult, 0, 0) );
  }

  // Get run type
  sprintf(query, "SELECT timestamp,end_timestamp FROM run_state WHERE run = %d", fRunNumber);
  qResult = PQexec(detectorDB, query);
  if (PQresultStatus(qResult) != PGRES_TUPLES_OK){
    warn<< " Query to DetectorDB failed. " << newline;
  }
  if(PQntuples(qResult)>0){
    char *start_ts = PQgetvalue(qResult, 0, 0);
    char *end_ts = PQgetvalue(qResult, 0, 1);
    std::tm tm_start = {}, tm_end = {};
    strptime(start_ts, "%Y-%m-%d %H:%M:%S", &tm_start);
    strptime(end_ts, "%Y-%m-%d %H:%M:%S", &tm_end);
    time_t start_time = mktime(&tm_start);
    time_t end_time = mktime(&tm_end);
    fRunLengthDB = end_time - start_time;

    if(fRunLengthDB < 0 || fRunLengthDB > 1e6) fRunLengthDB = -1.; //run can't be that long nor negative. This is a DB problem.

  }

  //Close connection
  PQclear(qResult);
  PQfinish(detectorDB);

}

void ProduceRunTableProc::printSummary(){

  info<<" ProduceRunTableProc: Run Type = "<<fRunTypeWord<<newline;
  info<<" ProduceRunTableProc: Calculated start time   = "
      <<fStart_times[0]<<" days, "
      <<fStart_times[1]<<" secs, "
      <<fStart_times[2]<<" nsec  "<<newline;
  info<<" ProduceRunTableProc: Calculated stop time   = "
      <<fStop_times[0]<<" days, "
      <<fStop_times[1]<<" secs, "
      <<fStop_times[2]<<" nsec  "<<newline;
  info<<" ProduceRunTableProc: Calculated run duration = "<<fRunLength<<newline;
  info<<" ProduceRunTableProc: DetectorDB run duration = "<<fRunLengthDB<<newline;

}

void ProduceRunTableProc::checkTimes(){

  /* Check that:
   * 1) Start or stop times are not zero
   * 2) Start or stop times are not invalid
   * 3) Run duration is not zero
   * 4) Run duration is similar to the one on DetectorDB */
  if( fStart_times[0]+fStart_times[1]+fStart_times[2]==0 ) setInvalidTimes(1);
  else if( fStop_times[0]+fStop_times[1]+fStop_times[2]==0 ) setInvalidTimes(1);

  if( fStart_times[0]==-1. || fStart_times[1]==-1. || fStart_times[2]==-1. ) setInvalidTimes(2);
  else if( fStop_times[0]==-1. || fStop_times[1]==-1. || fStop_times[2]==-1. ) setInvalidTimes(2);

  if(fRunLength == 0 ) setInvalidTimes(3);

  if( fRunLengthDB > 0 && std::abs(fRunLength - fRunLengthDB) > 5*60 ) //seconds
    setInvalidTimes(4);

}

void ProduceRunTableProc::setInvalidTimes(int log){

  switch(log){
  case 0:
    //Do not print
  case 1:
    warn<<" ProduceRunTableProc: Start or stop times are zero. Setting invalid times."<<newline;
    break;
  case 2:
    warn<<" ProduceRunTableProc: Start or stop times are invalid. Setting invalid times."<<newline;
    break;
  case 3:
    warn<<" ProduceRunTableProc: Run length is zero. Setting invalid times."<<newline;
    break;
  case 4:
    warn<<" ProduceRunTableProc: Run length largely differs from DetectorDB. Setting invalid times."<<newline;
    break;
  default:
    warn<<" ProduceRunTableProc: Setting invalid times. "<<newline;
  }

  fStart_times[0] = -1.;
  fStart_times[1] = -1.;
  fStart_times[2] = -1.;
  fStop_times[0] = -1.;
  fStop_times[1] = -1.;
  fStop_times[2] = -1.;

}