/// Class to hold and plot temperature inside TPC
/// at a particular time
/// Blair Jamieson (C) 2008
#ifndef TTPCTemperature_hxx__
#define TTPCTemperature_hxx__

#include <sys/time.h>
#include <iostream>
#include "ISlowControlDatabase.hxx"
#include "TPaveText.h"
#include "TList.h"
#include "TH2F.h"

const int  NTPCTEMPS=108;
const int  MAXNTPCS=3;

/// Class to hold and plot temperature inside TPC
/// at a particular time
/// Blair Jamieson 
class ITPCTemperature {
public:
  /// Initialize TPC temperature object using unix time
  ITPCTemperature( long autimemin = 1224118800,  long autimemax = 1224118800 );

  /// Initialize TPC temperature object using year, month(0-11),
  /// day(1-31),...
  ITPCTemperature( int ayearmin, int amonthmin, int adaymin, int ahourmin, int aminmin, int asecmin,
		   int ayearmax, int amonthmax, int adaymax, int ahourmax, int aminmax, int asecmax );

  /// Destructor does nothing... may leave a histogram
  /// floating around
  ~ITPCTemperature(){ 
    for (int iname=0; iname<NTPCTEMPS*MAXNTPCS; iname++){ 
      delete [] fNames[ iname ];
    }
    delete [] fNames;
  }
  
  
  /// Get temperature at probe nearest to X,Y,Z in TPCN coordinate
  /// system in degrees Celcius
  float GetT( float * aXYZ ){ 
    std::cout<<"<ITPCTemperature::GetT(aXYZ)> Not implemented, return zeroth temperature"<<std::endl;
    return fTemperature[0];
  }  

  /// Get time interval this record is valid for
  void GetTimeInterval(long &start_time, long &end_time);

  /// Get temperature at probe aT (0-35) in degrees Celcius
  float GetT( int aT ){ 
    if( aT>=0 && aT<fNTemps) return fTemperature[aT];
    else return -273.;
  }

  /// Get probe position aT(0-35)
  /// void  GetXYZ( int aT, float *aXYZ );
 
  /// Get unix time for this temperature reading
  long   GetTime(){ return fTime; }

  /// Get time for this reading as year, month(0-11), day(1-31),...
  void  GetTime( int &ayear, int &amonth, int &aday, int &ahour, int &amin, int &asec);
  
  /// Set the unix time for this object, and read temperatures closest
  /// to this time from database
  void  SetTime( long autime ){ fTime=autime; ReadNext(); }

  /// Set the time for this object
  void  SetTimeNoRead( int ayear, int amonth, int aday, int ahour, int amin, int asec=0 );

  /// Set the time for this object and read temperatures
  void  SetTime( int ayear, int amonth, int aday,  int ahour, int amin, int asec=0 ){
    SetTimeNoRead(ayear, amonth, aday, ahour, amin, asec);
    ReadNext();
  }

  /// Read the temperature reading (increment time) and update all
  /// object temperature readings. Argument passed is the minimum
  /// time increment to use (default 3 seconds)
  int  ReadNext(int adeltat=3);

  /// Return Histogram with temperature readings.
  TH2F * GetTH2F(){ return fHist; }

  /// Return timestamp
  char * GetTimeStamp(){ return fTimeStamp; }

  /// Return min, max temperature
  void GetMinMaxT( float &aTMin, float &aTMax){
    aTMin = fTempMin; aTMax = fTempMax;
  }

  /// Print bin mapping and tempereature names
  void PrintMap();

  /// Set Debug output flag
  void SetDebug( bool aOnOff = true ){ fDebug = aOnOff; }

  /// Get name of temperature for bin ix,iy in histogram
  const char * GetBinName( int ix, int iy );

private:
  int   fNTemps;
  long  fTime;                            ///< Unix time for fTemperature
  long  fTimeMin;                         ///< Intended minimum time for readings using this instance
  long  fTimeMax;                         ///< Intended maximum time for readings using this instance
  char *fTimeStamp;                       ///< local time as character array (for titles)
  float fTemperature[NTPCTEMPS*MAXNTPCS]; ///< Temperature
  float fTempMin;                         ///< Minimum Temperature
  float fTempMax;                         ///< Maximum Temperature
  double fTempAvg;                        ///< Average of all Temperatures
  float fX[NTPCTEMPS*MAXNTPCS];           ///< X position TPCN coordinate (cm)
  float fY[NTPCTEMPS*MAXNTPCS];           ///< Y position TPCN coordinate (cm)
  float fZ[NTPCTEMPS*MAXNTPCS];           ///< Z position TPCN coordinate (cm)
  TH2F *fHist;                            ///< Plot of temperatures
  int   fHistMap[NTPCTEMPS*MAXNTPCS];     ///< Index in histogram for temperature
  char **fNames;                          ///< pointer to set of names

  bool  fDebug;                           ///< Flag to print debug information to std::cout

  // this is a bit redundant, but left historical fNames to simplify
  // code update
  std::vector< std::string > fTPC_names[3];  ///< names of fields for Temperatures for each TPC

  /// Read another chunk of data from slow control database
  void ReadSlowControlDatabase();
  
  std::vector< std::pair< double, std::vector< double > > > fTPC_vec[3];  ///< db query result for Temperatures for each TPC

  /// Get index into each of the vectors of database query
  /// results for the current time
  void UpdateVectorTimeIdx();
  unsigned int fTPC_idx[3];  ///< time idx for current Temperature reading
  bool         fTPC_isok[3]; ///< db read was ok for current Temperature reading
  

  /// Set character timestamp from integer unix timestamp
  void SetupTimeStamp();

  /// Read the temperature readings
  void  Read();

  /// Initialize temperature object Sets offsets, makes histogram,
  /// reads tempearture, fills histogram
  void Init();
};

#endif //TTPCTemperature_hxx__