/// Class to hold MM HV Spark Properties inside TPC
/// at a particular time
/// Blair Jamieson (C) 2009, 2010

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


///--------------------------------------------------------------------
/// build new TTPC MM HV Spark reading with intended time range of use specified
ITPCMMSpark::ITPCMMSpark( long autimemin, long autimemax ){
  fTime = autimemin;
  fStartTime = autimemin;
  fEndTime = autimemax;
  fTimeStamp = 0x0;
  Init();
}

///--------------------------------------------------------------------
/// build new TTPC MM HV Spark reading with intended time range of use specified
ITPCMMSpark::ITPCMMSpark( 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 MM HV spark properties object
void ITPCMMSpark::Init(){

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

  // Now read MM HV spark properties
  Read();
}


///--------------------------------------------------------------------
/// Setup vectors of strings for field names
/// that will be querried in the database
void ITPCMMSpark::SetupFieldNames(){
  fSparks_names.clear();
  char aname[32];
  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for ( int imm=0; imm<12; imm++){
  sprintf(aname,"tpc%d_rp%d_mm%02d_sparkcount",itpc+1,irp,imm);
  fSparks_names.push_back( std::string(aname) );
      }
    }
  }
  return;
}


///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMSpark::ReadSlowDB(){
  /// read next 500 entries starting from 5 minutes ago
  long astart = fTime - 300;
  fSparks_vec.clear();
  fSparks_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpciseghv02_sparkcount", fSparks_names, 500 );
  return;
}

///--------------------------------------------------------------------
/// Print out the values for the current time
void ITPCMMSpark::Print(){
  std::cout<<"<ITPCMMSpark::Print> Record for "<<fTimeStamp<<" ctime="<<fTime<<std::endl;
  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for ( int imm=0; imm<12; imm++){
  int idx = itpc*2*12+irp*12+imm;
  std::cout<<(fSparks_names[idx]).c_str()<<":\t"<<fSparks[itpc][irp][imm]<<std::endl;
      }
    }
  }
  return;
}


///--------------------------------------------------------------------
/// Get the time interval for this record
void ITPCMMSpark::GetTimeInterval(long &start_time, long &end_time){
  start_time = fStart;
  end_time = fEnd;
  if ( fSparks_vec.size() > fSparks_idx[0][0][0]+2 ){
    start_time = (long) fSparks_vec[ fSparks_idx[0][0][0] ].first;
    end_time = (long) fSparks_vec[ fSparks_idx[0][0][0]+1 ].first;
  } else if ( fSparks_vec.size() < 2 ){
    end_time = fEndTime+1;
  }
  return;
}


///--------------------------------------------------------------------
/// Get unix time
long ITPCMMSpark::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 ITPCMMSpark::SetTimeNoRead( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  fTime = (int)GetUnixTime(ayear, amonth, aday, ahour, amin, asec );
  //std::cout<<"SetTimeNoRead "<<ayear<<"/"<<amonth<<"/"<<aday<<" "<<ahour<<":"<<amin<<":"<<asec<<" fTime="<<fTime<<std::endl;
}


///--------------------------------------------------------------------
/// Set sg timestamp from unix integer timestamp
void ITPCMMSpark::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);
  //std::cout<<"SetupTimeStamp "<<fTimeStamp<<" fTime="<<fTime<<std::endl;
}

///--------------------------------------------------------------------
/// Set the time for this object
void ITPCMMSpark::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 ITPCMMSpark::UpdateVectorTimeIdx(){
  
  // Find index for current time for Sparks
  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for ( int imm=0; imm<12; imm++){
  fSparks_idx[itpc][irp][imm] = 0;
  fSparks_isok[itpc][irp][imm] = false;
  // Find index for current time for Gain B
  if ( fSparks_vec.size()==1 ){
    fSparks_idx[itpc][irp][imm] = 0;
    fSparks_isok[itpc][irp][imm] = true;
  } else {  
    for (int i=0; i<int(fSparks_vec.size())-2; i++){
      if ( fTime >= long( (fSparks_vec[i].first) ) &&
     fTime <  long( (fSparks_vec[i+1].first) ) ) {
        fSparks_idx[itpc][irp][imm] = i;
        fSparks_isok[itpc][irp][imm] = true;
        break;
      }
    }
  }
      }
    }
  }

  return;
}


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

  //std::cout<<"<ITPCMMSpark::CheckReadDB> "<<fTimeStamp<<std::endl;
  if ( fSparks_vec.size() <= 2 ||
       fTime > long( fSparks_vec[ fSparks_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCMMSpark::CheckReadDB> About to ReadSlowDB_Plca"<<std::endl;
    ReadSlowDB();
  }
  return;
}

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

  // Read mm spark properties
  // since often they are not available, set to -1 for no reading
  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for ( int imm=0; imm<12; imm++){
  fSparks[itpc][irp][imm] = -1;
      }
    }
  }

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

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

  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for ( int imm=0; imm<12; imm++){
  int idx = itpc*2*12+irp*12+imm;
  if ( fSparks_isok[itpc][irp][imm] == true ){
    fSparks[itpc][irp][imm] = int( fSparks_vec[ fSparks_idx[itpc][irp][imm] ].second[ idx ] );
  }
      }
    }
  }
}


///--------------------------------------------------------------------
/// Read the next MM HV spark properties reading after current time setting and
/// update all readings.  Return 1 if all is okay otherwize return 
/// negative value.
int ITPCMMSpark::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;
}