//-----------------------------------------------------------------
// 
// Fuction to validate the DQ flags in the oaAnalysis files
//
// Author:
//         Francesca Di Lodovico (March 2011) - first version
//
//-----------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <strstream>
#include <stdlib.h>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <string>
#include "TROOT.h"
#include "TFile.h"
#include "TChain.h"
#include "TClonesArray.h"

// To use AnalysisTools utils in ACLiC mode then need to add the relevant header
// here and inside the ifdef so it is not seen by CINT. 
#if !defined(__CINT__) || defined(__MAKECINT__)
//Here include the header of your preferred AnalysisTools module
#endif 
using namespace std;

extern void runCommandDB(string type, int timeStart, int timeEnd, ofstream* outputDB);
extern void analysisDQFlags(char * inputfilename, int SubRun, ofstream *outfile, int max_entries = -1);


void runCommandDB(string type, int timeStart, int timeEnd) {
  FILE *fp;
  char path[200];
        string commandPath = string(getenv("OADATAQUALITYROOT")) + "/macros/validateoaAnalysis.py ";
  string command;
  int location;
  int newlocation;
  int loc;
  int lengthstring;
  bool resultsFlag = false;
  int * returnData = new int[6];
  for (int i = 0 ; i < 6; i++)returnData[i] = -1;
  string returnString;
  int count = 0;

  std::stringstream timeStStart;
  std::stringstream timeStEnd;
  timeStStart << timeStart;
  timeStEnd << timeEnd;
        command = commandPath + " -p -s " + type + " -b " + timeStStart.str() + " -e " + timeStEnd.str();
  //cout<<"Running command: "<<command<<endl;
  int status = system(command.c_str());
  if (status != 0) {
    printf("Failed to run command\n ");
    cout<<"status "<<status<<endl;
    exit(1);
  }
}

void analysisDQFlags(char * inputfilename, int SubRun, ofstream *outfile, int max_entries = -1){
  gROOT->SetBatch(1);

// See commented code below for loading libraries automatically.
//#if !defined(__MAKECINT__)
  // This should not be seen when using ACLiC.
  //gROOT->ProcessLine(".x oaAnalysisReadInitFile.C");
  //#endif
  // _________________________________________________________________________
  // Prepare to read trees and then read trees.
  //
  std::cout << "Adding file(s) matching string: " << inputfilename << std::endl;                  
  
  //
  // BasicHeader Info
  //
  TChain BasicHeader = TChain("HeaderDir/BasicHeader");
  //std::cout << "Adding file(s) matching string: " << inputfilename << std::endl;                  
  //std::cout << "Added "<< BasicHeader.AddFile(inputfilename) << " file(s)"<< std::endl;
  BasicHeader.AddFile(inputfilename);
  Int_t EventID;
  Int_t RunID;
  UInt_t EventTime;
  BasicHeader.SetBranchAddress("EventTime", &EventTime);                                 
  BasicHeader.SetBranchAddress("EventID", &EventID);                                  
  BasicHeader.SetBranchAddress("RunID", &RunID);                                  

  //
  // BasicDataQuality Info
  //
  TChain BasicDataQuality = TChain("HeaderDir/BasicDataQuality");
  //std::cout << "Adding file(s) matching string: " << inputfilename << std::endl;                  
  //std::cout << "Added "<< BasicDataQuality.AddFile(inputfilename) << " file(s)"<< std::endl;         
  BasicDataQuality.AddFile(inputfilename);
  Int_t DQEventID;
  Int_t DQRunID;
  Int_t COMETOffFlag(-100000),TPCFlag(-100000),TPC1Flag(-100000),TPC2Flag(-100000),TPC3Flag(-100000),FGDFlag(-100000),FGD1Flag(-100000),FGD2Flag(-100000),ECALFlag(-100000),DSECALFlag(-100000),BarECALFlag(-100000),P0DECALFlag(-100000),P0DFlag(-100000),SMRDFlag(-100000),MAGNETFlag(-100000),INGRIDFlag(-100000);
  BasicDataQuality.SetBranchAddress("EventID", &DQEventID);                                  
  BasicDataQuality.SetBranchAddress("RunID", &DQRunID);                                  
  BasicDataQuality.SetBranchAddress("COMETOffFlag", &COMETOffFlag);                                  
  BasicDataQuality.SetBranchAddress("TPCFlag", &TPCFlag);                                  
  BasicDataQuality.SetBranchAddress("TPC1Flag", &TPC1Flag);                                  
  BasicDataQuality.SetBranchAddress("TPC2Flag", &TPC2Flag);                                  
  BasicDataQuality.SetBranchAddress("TPC3Flag", &TPC3Flag);                                  
  BasicDataQuality.SetBranchAddress("FGDFlag", &FGDFlag);                                  
  BasicDataQuality.SetBranchAddress("FGD1Flag", &FGD1Flag);                                  
  BasicDataQuality.SetBranchAddress("FGD2Flag", &FGD2Flag);                                  
  BasicDataQuality.SetBranchAddress("ECALFlag", &ECALFlag);                                  
  BasicDataQuality.SetBranchAddress("DSECALFlag", &DSECALFlag);                                  
  BasicDataQuality.SetBranchAddress("BarECALFlag", &BarECALFlag);                                  
  BasicDataQuality.SetBranchAddress("P0DECALFlag", &P0DECALFlag);                                  
  BasicDataQuality.SetBranchAddress("P0DFlag", &P0DFlag);                                  
  BasicDataQuality.SetBranchAddress("SMRDFlag", &SMRDFlag);                                  
  BasicDataQuality.SetBranchAddress("MAGNETFlag", &MAGNETFlag);                                  
  BasicDataQuality.SetBranchAddress("INGRIDFlag", &INGRIDFlag);                                  

  // _________________________________________________________________________
  // Now loop over the entries in the input tree. Each entry corresponds to an
  // COMETEvent and it is safe to assume a correspondence between entries on 
  // different trees in the same analysis output file.  
  // However a check is performed anyway.

  // Loop over all events and extract flag info
  BasicHeader.GetEntry(0);
  BasicDataQuality.GetEntry(0);
  int entries = BasicHeader.GetEntries();
  if(max_entries > 0 && max_entries<entries) entries = max_entries;

  //First read the first and last timestamp of the file
  int timeStart(0);
  int timeEnd(0);
  BasicHeader.GetEntry(1);
  timeStart = int(EventTime);
  BasicHeader.GetEntry(entries-2);
  timeEnd = int(EventTime);

  //Then check the corresponding values of the flags in the production database
  int status = system("rm /tmp/mysql_results_TPC.tmp; touch /tmp/mysql_results_TPC.tmp ");
  int status = system("rm /tmp/mysql_results_FGD.tmp; touch /tmp/mysql_results_FGD.tmp ");
  int status = system("rm /tmp/mysql_results_ECAL.tmp; touch /tmp/mysql_results_ECAL.tmp ");
  int status = system("rm /tmp/mysql_results_P0D.tmp; touch /tmp/mysql_results_P0D.tmp ");
  int status = system("rm /tmp/mysql_results_SMRD.tmp; touch /tmp/mysql_results_SMRD.tmp ");
  int status = system("rm /tmp/mysql_results_MAGNET.tmp; touch /tmp/mysql_results_MAGNET.tmp ");
  int status = system("rm /tmp/mysql_results_INGRID.tmp; touch /tmp/mysql_results_INGRID.tmp ");
  runCommandDB("TPC", timeStart, timeEnd);
  runCommandDB("FGD", timeStart, timeEnd);
  runCommandDB("ECAL", timeStart, timeEnd);
  runCommandDB("P0D", timeStart, timeEnd);
  runCommandDB("SMRD", timeStart, timeEnd);
  runCommandDB("MAGNET", timeStart, timeEnd);
  runCommandDB("INGRID", timeStart, timeEnd);

  const int nmax(100); //assume that the max number of intervals
  const int ndet(7);
  UInt_t tbegin[ndet][nmax];  UInt_t tend[ndet][nmax];  Int_t flagDB[ndet][4][nmax];
  for (Int_t w = 0; w < 7 ; w++) {for (Int_t k = 0; k < nmax ; k++) {tbegin[w][k] = 0 ; tend[w][k] = 0 ; for (Int_t z = 0; z < 4 ; z++) {flagDB[w][z][k] = -1000000;}}}
  Int_t icount(-1);

  ifstream infileTPC("/tmp/mysql_results_TPC.tmp");
  while (! infileTPC.eof()) { 
    icount++; infileTPC >> flagDB[0][0][icount] >> flagDB[0][1][icount] >> flagDB[0][2][icount] >> flagDB[0][3][icount] >> tbegin[0][icount] >> tend[0][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file TPC - stop "<<endl;  exit(1);}
  } infileTPC.close();

  ifstream infileFGD("/tmp/mysql_results_FGD.tmp");
  while (! infileFGD.eof()) { 
    icount++; infileFGD >> flagDB[1][0][icount] >> flagDB[1][1][icount] >> flagDB[1][2][icount] >> flagDB[1][3][icount] >> tbegin[1][icount] >> tend[1][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file FGD - stop "<<endl;  exit(1);}
  } infileFGD.close();

  ifstream infileECAL("/tmp/mysql_results_ECAL.tmp");
  while (! infileECAL.eof()) { 
    icount++; infileECAL >> flagDB[2][0][icount] >> flagDB[2][1][icount] >> flagDB[2][2][icount] >> flagDB[2][3][icount] >> tbegin[2][icount] >> tend[2][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file ECAL - stop "<<endl;  exit(1);}
  } infileECAL.close();

  ifstream infileP0D("/tmp/mysql_results_P0D.tmp");
  while (! infileP0D.eof()) { 
    icount++; infileP0D >> flagDB[3][0][icount] >> flagDB[3][1][icount] >> flagDB[3][2][icount] >> flagDB[3][3][icount] >> tbegin[3][icount] >> tend[3][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file P0D - stop "<<endl;  exit(1);}
  } infileP0D.close();

  ifstream infileSMRD("/tmp/mysql_results_SMRD.tmp");
  while (! infileSMRD.eof()) { 
    icount++; infileSMRD >> flagDB[4][0][icount] >> flagDB[4][1][icount] >> flagDB[4][2][icount] >> flagDB[4][3][icount] >> tbegin[4][icount] >> tend[4][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file SMRD - stop "<<endl;  exit(1);}
  } infileSMRD.close();

  ifstream infileMAGNET("/tmp/mysql_results_MAGNET.tmp");
  while (! infileMAGNET.eof()) { 
    icount++; infileMAGNET >> flagDB[5][0][icount] >> flagDB[5][1][icount] >> flagDB[5][2][icount] >> flagDB[5][3][icount] >> tbegin[5][icount] >> tend[5][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file MAGNET - stop "<<endl;  exit(1);}
  } infileMAGNET.close();

  ifstream infileINGRID("/tmp/mysql_results_INGRID.tmp");
  while (! infileINGRID.eof()) { 
    icount++; infileINGRID >> flagDB[6][0][icount] >> flagDB[6][1][icount] >> flagDB[6][2][icount] >> flagDB[6][3][icount] >> tbegin[6][icount] >> tend[6][icount] ;
    if(icount == 99) {cout << "More than 100 intervals in a file INGRID - stop "<<endl;  exit(1);}
  } infileINGRID.close();


  for(int ientries = 0; ientries < entries; ientries++){
    if(ientries == 1 || ientries == (entries-2)) continue;
    //if (ientries%1000)  cout << "event # " << ientries << endl;
    BasicHeader.GetEntry(ientries);
    BasicDataQuality.GetEntry(ientries);
    if ( RunID != DQRunID || EventID != DQEventID ) {
      std::cout << "Runs and Event # mismatch." << std::endl;
      exit(1);
     }
    
    //Fill the flag values
    int flagAnalysis[7][4];
    for(int i = 0; i <7; i++) {for(int j = 0; j < 4 ; j++){flagAnalysis[i][j] = -1; }}
    flagAnalysis[0][0] = TPCFlag;
    flagAnalysis[0][1] = TPC1Flag;
    flagAnalysis[0][2] = TPC2Flag;
    flagAnalysis[0][3] = TPC3Flag;
    flagAnalysis[1][0] = FGDFlag;
    flagAnalysis[1][1] = FGD1Flag;
    flagAnalysis[1][2] = FGD2Flag;
    flagAnalysis[2][0] = ECALFlag;
    flagAnalysis[2][1] = DSECALFlag;
    flagAnalysis[2][2] = BarECALFlag;
    flagAnalysis[2][3] = P0DECALFlag;
    flagAnalysis[3][0] = P0DFlag;
    flagAnalysis[4][0] = SMRDFlag;
    flagAnalysis[5][0] = MAGNETFlag;
    flagAnalysis[6][0] = INGRIDFlag;
    
    // Compare the values in the root file and on the database
    std::cout.precision(15);
    for(int i=0; i<icount; i++){
      for(int j=0; j<ndet; j++){
  if ( EventTime >= tbegin[j][i] && EventTime < tend[j][i] ) {
    for(int k=0; k<4; k++){
      if ( flagAnalysis[j][0] != flagDB[j][0][i] || flagAnalysis[j][1] != flagDB[j][1][i] || flagAnalysis[j][2] != flagDB[j][2][i] || flagAnalysis[j][3] != flagDB[j][3][i] ) {
        *outfile<<"Mismatch at: "<<j<<" "<<tbegin[j][i]<<" "<<tend[j][i]<<" "<<flagDB[j][0][i]<<" "<<flagAnalysis[j][0] <<" "<<flagDB[j][1][i]<<" "<<flagAnalysis[j][1] <<" "<<flagDB[2][i]<<" "<<flagAnalysis[j][2] <<" "<<flagDB[j][3][i]<<" "<<flagAnalysis[j][3] <<std::endl;
      }
    }
  }
      }    
    }
  }///end loop entries  

}