///------------------------------------------------------------------------
///
///    Description:  Example using the popen command to run a script and
///    read the output.
///
///    Author:  Francesca Di Lodovico
///
///------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <cstring>
#include <string>
#include "IDataQuality.hxx"

using namespace std;

int *runCommand(string type, int timeStamp) {
  FILE *fp;
  char path[200];
        string commandPath = string(getenv("OADATAQUALITYROOT")) + "/src/GetDQ.py ";
  string command;
  int location;
  int newlocation;
  int loc;
  int lengthstring;
  bool resultsFlag = false;
  int * returnData = new int[7];
  for (int i = 0 ; i < 7; i++)returnData[i] = -1;
  string returnString;
  int count = 0;

  std::stringstream timeStr;
  timeStr << timeStamp;
        command = commandPath + " -p -s " + type + " " + timeStr.str();

  fp = popen(command.c_str(), "r");
  if (fp == NULL) {
    printf("Failed to run command\n");
    exit(1);
  }
  // Returned string is flag, subdetector, starttime, endtime, createtime
  // with spaces between the strings. We need to split these and get
  // the flag. There are other strings returned, but the results of
  // interest appear after the --- RESULTS --- string
  while (fgets(path, sizeof(path)-1, fp) != NULL) {
    returnString = path;
    // Have found the result string. Lines after contain the
    // results
    loc = returnString.find("- RESULTS -");
    if (loc > 0) {
      resultsFlag = true;
      continue;
    }
    if (resultsFlag) {
      // Returned string contains seven space-separated values
      // flag startime endtime createtime
      location = returnString.find(" ");
      lengthstring = location;
      returnData[0] = atoi(returnString.substr(0, lengthstring).c_str());

      //cout<<"String "<<returnString<<endl;
      newlocation = lengthstring + 0 + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation;
      location = newlocation ;
      returnData[1] = atoi(returnString.substr(location, lengthstring).c_str());

      newlocation = lengthstring + location + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation ;
      location = newlocation ;
      returnData[2] = atoi(returnString.substr(location, lengthstring).c_str());

      newlocation = lengthstring + location + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation;
      location = newlocation ;
      returnData[3] = atoi(returnString.substr(location, lengthstring).c_str());

      newlocation = lengthstring + location + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation ;
      location = newlocation ;
      returnData[4] = atoi(returnString.substr(location, lengthstring).c_str());

      newlocation = lengthstring + location + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation ;
      location = newlocation ;
      returnData[5] = atoi(returnString.substr(location, lengthstring).c_str());

      newlocation = lengthstring + location + 1;
      lengthstring = returnString.find(" ", newlocation ) - newlocation ;
      location = newlocation ;
      returnData[6] = atoi(returnString.substr(location, lengthstring).c_str());

      //printf("Flag1 %d \n", returnData[0]);
      //printf("Flag2 %d \n", returnData[1]);
      //printf("Flag3 %d \n", returnData[2]);
      //printf("Flag4 %d \n", returnData[3]);
      //printf("Starttime %d \n", returnData[4]);
      //printf("Endtime %d \n", returnData[5]);
      //printf("Createtime %d \n", returnData[6]);
    }
    ++count;
  }
  pclose(fp);
  //cout << "count is: " << count << endl;
  if (count == 1) {
    cout << "***** No Value found for subdetector: " << type << " and eventtime: " << timeStamp << endl;
  }
  return returnData;
}

COMET::IDataQuality::IDataQuality(void) {
  allFlags = -1;
  TPCFlag = -1;
  TPC1Flag = -1;
  TPC2Flag = -1;
  TPC3Flag = -1;
  FGDFlag = -1;
  FGD1Flag = -1;
  FGD2Flag = -1;
  ECALFlag = -1;
  DSECALFlag = -1;
  BarECALFlag = -1;
  P0DECALFlag = -1;
  P0DFlag = -1;
  SMRDFlag = -1;
  MAGNETFlag = -1;
  INGRIDFlag = -1;
  TPCData = NULL;
  FGDData = NULL;
  ECALData = NULL;
  P0DData = NULL;
  SMRDData = NULL;
  MAGNETData = NULL;
  INGRIDData = NULL;
}

int COMET::IDataQuality::TPCStatus(void) {
  return TPCFlag;
}
int COMET::IDataQuality::TPC1Status(void) {
  return TPC1Flag;
}
int COMET::IDataQuality::TPC2Status(void) {
  return TPC2Flag;
}
int COMET::IDataQuality::TPC3Status(void) {
  return TPC3Flag;
}

int COMET::IDataQuality::FGDStatus(void) {
  return FGDFlag;
}
int COMET::IDataQuality::FGD1Status(void) {
  return FGD1Flag;
}
int COMET::IDataQuality::FGD2Status(void) {
  return FGD2Flag;
}

int COMET::IDataQuality::ECALStatus(void) {
  return ECALFlag;
}
int COMET::IDataQuality::DSECALStatus(void) {
  return DSECALFlag;
}
int COMET::IDataQuality::BarECALStatus(void) {
  return BarECALFlag;
}
int COMET::IDataQuality::P0DECALStatus(void) {
  return P0DECALFlag;
}

int COMET::IDataQuality::P0DStatus(void) {
  return P0DFlag;
}

int COMET::IDataQuality::SMRDStatus(void) {
  return SMRDFlag;
}

int COMET::IDataQuality::MAGNETStatus(void) {
  return MAGNETFlag;
}

int COMET::IDataQuality::INGRIDStatus(void) {
  return INGRIDFlag;
}

int COMET::IDataQuality::AllStatus(void) {
  return allFlags;
}

void COMET::IDataQuality::getStatus(int timeStamp) {
  
  // Check if we have read from the database. If we have then check
  // if the timestamp for the event is within the start and end time
  // if it is we don't need to read the database again. If it isn't
  // then we should re-read the database.

        int nflags(4);
  if (TPCData != NULL) {
    if (!(timeStamp >= *(TPCData+nflags) && timeStamp <= *(TPCData+(nflags+1)))) {
      cout << "**** TPC re-reading from database" << endl;
      TPCData = runCommand("TPC", timeStamp);
    }
  } else {
    cout << "**** have not read the database for TPC will read it" << endl;
    TPCData = runCommand("TPC", timeStamp);
  }
  
  // Get FGD status (approach is same as for TPC subdetector).
  if (FGDData != NULL) {
    if (!(timeStamp >= *(FGDData+nflags) && timeStamp <= *(FGDData+(nflags+1)))) {
      cout << "**** FGD re-reading from database" << endl;
      FGDData = runCommand("FGD", timeStamp);
    }
  } else {
    cout << "**** have not read the database for FGD will read it" << endl;
    FGDData = runCommand("FGD", timeStamp);
  }
  // Get ECAL status (approach is same as for TPC subdetector).
  if (ECALData != NULL) {
    if (!(timeStamp >= *(ECALData+nflags) && timeStamp <= *(ECALData+(nflags+1)))) {
      cout << "**** ECAL re-reading from database" << endl;
      ECALData = runCommand("ECAL", timeStamp);
    }
  } else {
    cout << "**** have not read the database for ECAL will read it" << endl;
    ECALData = runCommand("ECAL", timeStamp);
  }
  // Get P0D status (approach is same as for TPC subdetector).
  if (P0DData != NULL) {
    if (!(timeStamp >= *(P0DData+nflags) && timeStamp <= *(P0DData+(nflags+1)))) {
      cout << "**** P0D re-reading from database" << endl;
      P0DData = runCommand("P0D", timeStamp);
    }
  } else {
    cout << "**** have not read the database for P0D will read it" << endl;
    P0DData = runCommand("P0D", timeStamp);
  }
  // Get SMRD status (approach is same as for TPC subdetector).
  if (SMRDData != NULL) {
    if (!(timeStamp >= *(SMRDData+nflags) && timeStamp <= *(SMRDData+(nflags+1)))) {
      cout << "**** SMRD re-reading from database" << endl;
      SMRDData = runCommand("SMRD", timeStamp);
    }
  } else {
    cout << "**** have not read the database for SMRD will read it" << endl;
    SMRDData = runCommand("SMRD", timeStamp);
  }
  // Get MAGNET status (approach is same as for TPC subdetector).
  if (MAGNETData != NULL) {
    if (!(timeStamp >= *(MAGNETData+nflags) && timeStamp <= *(MAGNETData+(nflags+1)))) {
      cout << "**** MAGNET re-reading from database" << endl;
      MAGNETData = runCommand("MAGNET", timeStamp);
    }
  } else {
    cout << "**** have not read the database for MAGNET will read it" << endl;
    MAGNETData = runCommand("MAGNET", timeStamp);
  }
  // Get INGRID status (approach is same as for TPC subdetector).
  if (INGRIDData != NULL) {
    if (!(timeStamp >= *(INGRIDData+nflags) && timeStamp <= *(INGRIDData+(nflags+1)))) {
      cout << "**** INGRID re-reading from database" << endl;
      INGRIDData = runCommand("INGRID", timeStamp);
    }
  } else {
    cout << "**** have not read the database for INGRID will read it" << endl;
    INGRIDData = runCommand("INGRID", timeStamp);
  }
  
  // Load the flags
  TPCFlag = TPCData[0];
  TPC1Flag = TPCData[1];
  TPC2Flag = TPCData[2];
  TPC3Flag = TPCData[3];
  FGDFlag = FGDData[0];
  FGD1Flag = FGDData[1];
  FGD2Flag = FGDData[2];
  ECALFlag = ECALData[0];
  DSECALFlag = ECALData[1];
  P0DECALFlag = ECALData[2];
  BarECALFlag = ECALData[3];
  P0DFlag = P0DData[0];
  SMRDFlag = SMRDData[0];
  MAGNETFlag = MAGNETData[0];
  INGRIDFlag = INGRIDData[0];
  // Add the flags to get the total COMET off-axis flag 
  if(TPCFlag>-1 && FGDFlag>-1 && ECALFlag>-1 && P0DFlag>-1 && SMRDFlag>-1 && MAGNETFlag>-1){
    allFlags = TPCFlag + FGDFlag + ECALFlag + P0DFlag + SMRDFlag + MAGNETFlag;
    if(allFlags>0) allFlags=1; //the info regarding each subdetector can be obtained from the subdetectors themselves
  }
}