/// Class to read magnet current over a time range
/// and provide the average / RMS values.
/// Blair Jamieson (C) 2010

#include <string>
#include <math.h>
#include "IMagnetCurrent.hxx"


///--------------------------------------------------------------------
/// build new Magnet Current reading with intended time range of use specified
IMagnetCurrent::IMagnetCurrent( long autimemin, long autimemax ){
  fTime = autimemin;
  fStartTime = autimemin;
  fEndTime = autimemax;
  fTimeStamp = 0x0;
  Init();
}

///--------------------------------------------------------------------
/// build new Magnet Current reading with intended time range of use specified
IMagnetCurrent::IMagnetCurrent( int ayearmin, int amonthmin, int adaymin, int ahourmin, int aminmin, int asecmin,
				int ayearmax, int amonthmax, int adaymax, int ahourmax, int aminmax, int asecmax ){
  fTimeStamp=0x0;
  SetTimeNoRead(ayearmax, amonthmax, adaymax, ahourmax, aminmax, asecmax);
  fEndTime = fTime;
  SetTimeNoRead(ayearmin, amonthmin, adaymin, ahourmin, aminmin, asecmin);
  fStartTime = fTime;
  Init();
}



/// Initialize magnet current object
void IMagnetCurrent::Init(){
  char * aCtime;//[256];
  aCtime = ctime(  (const time_t*)&fStartTime );
  int aslen = strlen(aCtime);
  //if (fTimeStampMin!=0x0) delete [] fTimeStampMin;
  fTimeStampMin = new char[aslen+1];
  sprintf(fTimeStampMin,"%s",aCtime);
  fTimeStampMin[aslen-1] = 0x0;

  aCtime = ctime(  (const time_t*)&fEndTime );
  aslen = strlen(aCtime);
  //if (fTimeStampMax!=0x0) delete [] fTimeStampMax;
  fTimeStampMax = new char[aslen+1];
  sprintf(fTimeStampMax,"%s",aCtime);
  fTimeStampMax[aslen-1] = 0x0;

  // set up the field names
  SetupFieldNames();
  fI_vec.clear();

  // Now read magnet currents properties
  Read();

  // setup mean, rms
  GetTimeInterval(fStart,fEnd);  
  int nquery = 0;
  do {
    if (fI >= -0.1){ // filter bad readings
      fIAvg.Add( fTime, fI );
    } else {
      COMETLog("Bad reading at time "<<fTimeStamp);
    }
    //if (nquery%500==0) std::cout<<"query "<<nquery<<" at "<<fTimeStamp<<std::endl;
    ReadNext();
    GetTimeInterval(fStart,fEnd);
    nquery++;
  } while ( fEnd < fEndTime );
  fIAvg.Add( fTime, fI, true );

  // set back to initial time
  SetTime( fStartTime );

}


///--------------------------------------------------------------------
/// Setup vectors of strings for field names
/// that will be querried in the database
void IMagnetCurrent::SetupFieldNames(){
  fI_names.clear();
  fI_names.push_back("curr_65_value");
  return;
}


///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void IMagnetCurrent::ReadSlowDB_I(){
  /// read next 500 entries starting from 1000 s ago
  long astart = fTime - 1000;
  int nread = 500;
  if ( fI_vec.size()>2 ){
    int adt = int( fI_vec[1].first - fI_vec[0].first);
    if ( adt > 0 ) nread = (fEndTime - astart)/adt;
    else nread = (fEndTime - astart)/300; // assume every 5 minutes?
    if ( nread > 20000 ) nread = 20000;
    if ( nread < 100 ) nread = 100;
    //std::cout<<"adt="<<adt<<" nread="<<nread<<std::endl;
  }
  fI_vec.clear();

  // Execute database query.
  fI_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "magnet_curr_65", fI_names, nread );

  // Do a quick little check that we have actually found a database row that comes before
  // our desired time.  Sometimes this will fail, because the database wasn't always getting
  // consistently written.
  if(fI_vec.size() != 0 && fI_vec[0].first > fTime && fI_names.size() != 0){
    // This access method is guaranteed to return a table row before fTime, as long as 
    // such a row actually exists.
    double backup_current = ISlowControlDatabase::Get().QueryShowField(fTime,"magnet_curr_65",fI_names[0].c_str());
    double backup_time = ISlowControlDatabase::Get().QueryShowField(fTime,"magnet_curr_65","_i_time");

    COMETLog("IMagnetCurrent::ReadSlowDB_I : Found some unexpected gaps in magnet current GSC table.\n"
             << "Using backup table row: " << backup_current << " "<< backup_time);
    fI_vec[0].first     = backup_time;
    fI_vec[0].second[0] = backup_current;    
  }


  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from offline database
bool IMagnetCurrent::ReadOfflineDB_I(){

  COMET::ICOMETEvent *event = COMET::IEventFolder::GetCurrentEvent();
  COMET::ICOMETContext context = event->GetContext();
  context.SetPartition(0);

  COMET::IResultSetHandle<COMET::IMagnetCurrent_DB_Table> rs(context);
  
  Int_t numRows(rs.GetNumRows());
  if(numRows == 0) {
    COMETLog("Not able to read from offline db");
    return false;
  }

  COMETLog("Applying query at " << UnixTimeToDateTime(context.GetTimeStamp()) << " ... result IMagnetCurrent_DB_Table set contains "
	   << numRows << " rows");

  fI_vec.clear();
  for (Int_t irow = 0; irow<numRows; ++irow) {

    std::vector<double> current_fields;
    std::pair<double,std::vector<double> > current_data;

    current_data.first = rs.GetRow(irow)->GetTime();

    current_fields.push_back(rs.GetRow(irow)->GetCurrent());    
    current_data.second = current_fields;
 
    fI_vec.push_back(current_data);
  }

  return true;
}

///--------------------------------------------------------------------
/// Print out the values for the current time
void IMagnetCurrent::Print(){  
  std::cout<<"<IMagnetCurrent::Print> Record for "<<fTimeStamp<<" ctime="<<fTime<<":"<<std::endl;
  std::cout<<"Magnet Current      (A):\t"<<fI<<std::endl;
  std::cout<<"Statistics from "<<fTimeStampMin<<" to "<<fTimeStampMax<<":"<<std::endl;
  fIAvg.Print("Magnet Current (A)");
  return;
}


///--------------------------------------------------------------------
/// Get the time interval for this record
void IMagnetCurrent::GetTimeInterval(long &start_time, long &end_time){
  start_time = fStart;
  end_time = fEnd;
  if ( fI_vec.size() > fI_idx+2 ){
    start_time = (long) fI_vec[ fI_idx ].first;
    end_time = (long) fI_vec[ fI_idx+1 ].first;
  }
  return;
}


///--------------------------------------------------------------------
/// Get unix time
long IMagnetCurrent::GetUnixTime( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  tm mt;
  // use time structure from time.h
  // to build unix time from year,month, etc.
  mt.tm_year = ayear - 1900;
  mt.tm_mon  = amonth-1;
  mt.tm_mday = aday;
  mt.tm_hour = ahour;
  mt.tm_min  = amin;
  mt.tm_sec  = asec;
  mt.tm_isdst = -1;
  return (long)mktime(&mt);
}


///--------------------------------------------------------------------
/// Set the time for this object
void IMagnetCurrent::SetTimeNoRead( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  fTime = (int)GetUnixTime(ayear, amonth, aday, ahour, amin, asec );
}


///--------------------------------------------------------------------
/// Set timestamp from unix integer timestamp
void IMagnetCurrent::SetupTimeStamp(){
  char * aCtime;//[256];
  aCtime = ctime(  (const time_t*)&fTime );
  int aslen = strlen(aCtime);
  if (fTimeStamp!=0x0) delete [] fTimeStamp;
  fTimeStamp = new char[aslen+1];
  sprintf(fTimeStamp,"%s",aCtime);
  fTimeStamp[aslen-1] = 0x0;
}

///--------------------------------------------------------------------
/// Set the time for this object
void IMagnetCurrent::GetTime( int &ayear, int &amonth, int &aday, int &ahour, int &amin, int &asec) {
  tm mt;  
  // use time structure from time.h to get time 
  localtime_r( (const time_t*) &fTime, &mt );
  // to build unix time from year,month, etc.
  ayear = 1900 + mt.tm_year;
  amonth = mt.tm_mon;
  aday = mt.tm_mday;
  ahour = mt.tm_hour;
  amin = mt.tm_min;
  asec = mt.tm_sec;
}


///------------------------------------------------------------------------
/// Get index into each of the vectors of database query
/// results for the current time
void IMagnetCurrent::UpdateVectorTimeIdx(){
  
  // Find index for current time for magnet current
  fMagI_isok = false;
  fI_idx=0;
  if ( fI_vec.size()<2 ) return;
  for (unsigned int i=0; i<fI_vec.size()-2; i++){
    if ( fTime >= long( (fI_vec[i].first) ) &&
         fTime <  long( (fI_vec[i+1].first) ) ) {
      fI_idx = i;
      fMagI_isok = true;
      break;
    }
  }
  return;
}


///--------------------------------------------------------------------
/// Check if anouther chunk of data needs to be read from 
/// slow control database
void IMagnetCurrent::CheckReadDB(){

  if ( fI_vec.size() <= 3 ||
       fTime < long( fI_vec[ 0 ].first )  ||
       fTime > long( fI_vec[ fI_vec.size()-3 ].first ) ){
    //std::cout<<"<IMagnetCurrent::CheckReadDB> About to ReadSlowDB_I"<<std::endl;
    bool readoffline = ReadOfflineDB_I();     

    if(readoffline == false) 
      ReadSlowDB_I();
  }
  return;
}

///--------------------------------------------------------------------
/// Read the temperature reading and update all
/// object temperature readings. 
void IMagnetCurrent::Read(){
  SetupTimeStamp();

  // set to bad value
  fI  = -1.;

  // Check if we need to read more data
  // from slow control database
  CheckReadDB();

  // Get index into vector of database query
  // results for the current time
  UpdateVectorTimeIdx();

  if ( fMagI_isok == true ){
    //std::cout<<"MagI_isok="<<fMagI_isok<<" fI_idx="<<fI_idx<<" size="<<fI_vec.size()<<std::endl;
    fI = fI_vec[ fI_idx ].second[0];

    // Check for bad values of magnet current.  If below
    // some value, then just return magnet current of exactly 0A.
    if(fI < 20 && fI > -20)
      fI = 0.0;
  }
}


///--------------------------------------------------------------------
/// Read the next gas properties reading after current time setting and
/// update all readings.  Return 1 if all is okay otherwize return 
/// negative value.
int IMagnetCurrent::ReadNext(int adeltat){

  static int amult = 1;
  
  GetTimeInterval(fStart,fEnd);
  
  if (fStart+adeltat > fEnd){
    amult = 1;
    fTime = fTime + adeltat;
  } else {
    if ( fEnd+1 <= fTime ){
      // handle case where no readings for a while
      amult*=2;
      fTime += amult;

    } else {
      amult = 1;
      fTime = fEnd+1;
    }
  }

  
  Read();

  return 1;
}