#include <cstdlib>
#include <iostream>
#include <fstream>
#include <TTimeStamp.h>
#include <TObjString.h>
#include <TObjArray.h>

#include "ISlowControlDatabase.hxx"

void help(char *exename){

  std::cout << "Usage:"<<std::endl;
  std::cout << "    " << exename << " [-s YYYY MM DD HH MM SS -e YYYY MM DD HH MM SS | -l -o <filename>]"<< std::endl;
  std::cout << "      -s specify year month day minute and second of start period"<< std::endl;
  std::cout << "      -e specify year month day minute and second of start period"<< std::endl;
  std::cout << "      -l dump current values from last date saved to offline db"<< std::endl;
  std::cout << "      -o <filename>"<< std::endl;
  return;
}

std::string exec(std::string cmd) {
  FILE* pipe = popen(cmd.c_str(), "r");
  if (!pipe) return "ERROR";
  char buffer[128];
  std::string result = "";
  while(!feof(pipe)) {
    if(fgets(buffer, 128, pipe) != NULL)
      result += buffer;
  }
  pclose(pipe);
  return result;
}

std::string makeCommand() {
  TString url =  getenv("ENV_TSQL_URL");
  TObjArray* Strings = url.Tokenize("//");

  const char* server = ((TObjString*)Strings->At(1))->GetString().Data();
  const char* db     = ((TObjString*)Strings->At(2))->GetString().Data();  
  const char* user = getenv("ENV_TSQL_USER");
  const char* pwd  = getenv("ENV_TSQL_PSWD");

  std::string cmd = Form("mysql -s -h %s -u %s --password=%s -D %s -A -e \"select max(i_time) from MAGNETCURRENT_DB_TABLE;\" | tail -1",server,user,pwd,db);
  return cmd;
}

int main(int argc,char **argv){
    
  UInt_t syear=0;
  UInt_t smonth=0;
  UInt_t sday=0;
  UInt_t shour=0;
  UInt_t smin=0;
  UInt_t ssec=0;

  UInt_t eyear=0;
  UInt_t emonth=0;
  UInt_t eday=0;
  UInt_t ehour=0;
  UInt_t emin=0;
  UInt_t esec=0;

  char* fname = NULL;

  // ***** process command line arguments ... 
  Int_t i=1;
  while ( i < argc ) {
    if ( strcmp(argv[i],"-h") == 0 // || argc < 14
   ) {
      help(argv[0]);
      exit(1);
    }
    else if ( strcmp(argv[i],"-e") == 0 ) {
      eyear  = atoi( argv[++i] );
      emonth = atoi( argv[++i] );
      eday   = atoi( argv[++i] );
      ehour  = atoi( argv[++i] );
      emin   = atoi( argv[++i] );
      esec   = atoi( argv[++i] );
    }
    else if ( strcmp(argv[i],"-s") == 0 ) {
      syear  = atoi( argv[++i] );
      smonth = atoi( argv[++i] );
      sday   = atoi( argv[++i] );
      shour  = atoi( argv[++i] );
      smin   = atoi( argv[++i] );
      ssec   = atoi( argv[++i] );
    }
    else if ( strcmp(argv[i],"-l") == 0 ) {
      std::string cmd = makeCommand();      
      std::string output = exec(cmd);
      UInt_t last_time = atol(output.c_str());

      TTimeStamp start(last_time);
      start.GetDate(kTRUE,0,&syear,&smonth,&sday);
      start.GetTime(kTRUE,0,&shour,&smin,&ssec);

      TTimeStamp end;
      end.GetDate(kTRUE,0,&eyear,&emonth,&eday);
      end.GetTime(kTRUE,0,&ehour,&emin,&esec);
    }
    else if ( strcmp(argv[i],"-o") == 0 ) {
      fname = argv[++i];
    }
    i++;
  }
  
  if ( syear==0 || eyear==0 ){
    std::cout<<"ERROR. One of date parameters missing."<<std::endl;
    help(argv[0]);
    exit(1);
  }

  TTimeStamp ts;

  ts.Set(syear,smonth,sday,shour,smin,ssec,0,kTRUE,0);
  long start_time = ts.GetSec();

  ts.Set(eyear,emonth,eday,ehour,emin,esec,0,kTRUE,0);
  long end_time = ts.GetSec();

  /*
    +-------------------+------------+------+-----+-------------------+-------+
    | Field             | Type       | Null | Key | Default           | Extra |
    +-------------------+------------+------+-----+-------------------+-------+
    | _t_time           | timestamp  | NO   |     | CURRENT_TIMESTAMP |       | GMT timestamp in string format
    | _i_time           | int(11)    | YES  |     | NULL              |       | Japan UNIX time = GMT + 9 hours
    | curr_65_enabled   | tinyint(4) | YES  |     | NULL              |       | 
    | curr_65_value     | float      | YES  |     | NULL              |       | current value
    | curr_65_timestamp | int(11)    | YES  |     | NULL              |       | upload time
    +-------------------+------------+------+-----+-------------------+-------+
  */

  // First make up the list of table variables we want 
  std::vector<std::string> table_fields;

  // Add variables from table.
  table_fields.push_back("_t_time");
  table_fields.push_back("_i_time");
  table_fields.push_back("curr_65_enabled");
  table_fields.push_back("curr_65_value");
  table_fields.push_back("curr_65_timestamp");

  int aggregate = 500;
  int task =0;

  char table_name[256];
  sprintf(table_name,"magnet_curr_65");

  // Now execute database query.
  std::vector<std::pair<double,std::vector<double> > > returned_values = 
    ISlowControlDatabase::Get().QueryGetFieldStartEndTime(table_name, table_fields, start_time, end_time);

  // Now let's look at what we got back.
  int nvalues = returned_values.size();
  if(nvalues==0) return 0;

  std::cout<<"Dumping "<<nvalues<<" values"<<std::endl;

  //Define validity period
  long start_row_time = returned_values[0].first;
  long end_row_time   = returned_values[nvalues-1].first;

  TTimeStamp  start_vld_time(start_row_time);
  TTimeStamp  end_vld_time  (end_row_time);
  TTimeStamp  creation_time;

  char start_vld_time_string[256];
  sprintf(start_vld_time_string,"'%s'",start_vld_time.AsString("s"));

  char end_vld_time_string[256];
  sprintf(end_vld_time_string,"'%s'",end_vld_time.AsString("s"));

  char creation_time_string[256];
  sprintf(creation_time_string,"'%s'",creation_time.AsString("s"));

  // The overall loop contains the information for each row of database that was between start_time and end_time.
    
  // Open file to dump results
  char aname[256];
  if(fname) 
    sprintf(aname,"%s",fname);
  else
    sprintf(aname,"magnetcurrent_%ld_to_%ld.dat",start_row_time,end_row_time);
  
  ofstream outfile; ///< Output file
  outfile.open(aname, ofstream::out);
  outfile<<"BEGIN_TABLE MAGNETCURRENT_DB_TABLE "
   <<start_vld_time_string<<" "
   <<end_vld_time_string<<" "
   <<aggregate<<" "
   <<creation_time_string<<" "
   <<task<<" "
   <<std::endl;

  for(unsigned int row = 0; row < returned_values.size(); row++){

    // The first part of pair for this row stores the timestamp for this row
    long row_time = returned_values[row].first;

    // The second part of pair for this row contains the vector of the variables you asked for.        
    std::vector<double> variables = returned_values[row].second;

    // Now retrieve the individual measurements we asked for:
    // int _t_time = variables[0];
    // int _i_time = variables[1]; //=row_time
    int curr_65_enabled = variables[2];
    double curr_65_value = variables[3];
    // int curr_65_timestamp = variables[4];

    if(curr_65_enabled != 1) continue;
    if(row_time<start_time) continue;

    TTimeStamp check(row_time);
    outfile << row_time << ", "
      << curr_65_enabled<<", "
      << curr_65_value
      << std::endl;
               
  }

  return 0;
}