#include <vector>
#include <map>
#include <fstream>
#include <sstream>
#include <iostream>
#include <TObject.h>
#include <TTree.h>
#include <TString.h>
#include <TStyle.h>
#include <TFile.h>
#include <TH2.h>
#include <math.h> 
#include <TMinuit.h>
#include "CalibrationConstants.h"

class Calibrator : public TObject {
private:
  // Variables
  TFile*                 m_file;
  TTree*                 m_data;
  TTree*                 m_bkg;
  int                    m_dataCellID[2];
  float                  m_dataE[2];
  float                  m_dataEPrs[2];
  float                  m_dataCosPhi;
  int                    m_bkgCellID[2];
  float                  m_bkgE[2];
  float                  m_bkgEPrs[2];
  float                  m_bkgCosPhi;  
  std::map< int , int >  m_cellIDs;
  CalibrationConstants*  m_constantsInit;
  CalibrationConstants*  m_constantsFinal;  
  // Minimization
  friend void FCN( Int_t&, Double_t*, Double_t&, Double_t*, Int_t );
  void loadFile( TString );
  void loadBranches( TFile* );
  int activate();
  int deactivate();
  void minimize();
  void minimizer_all( Int_t&, Double_t*, Double_t&, Double_t*, Int_t );
  // Functor
  
public:
  // Constructors and configuration
  Calibrator() : m_file( NULL ) , m_data( NULL ) , m_bkg( NULL ) { m_constantsInit = new CalibrationConstants(); m_constantsFinal = new CalibrationConstants(); };
  Calibrator( TFile* , CalibrationConstants* );
  Calibrator( TString , CalibrationConstants* );
  Calibrator( TFile* , TString );
  Calibrator( TString , TString );
  ~Calibrator(){ m_file->Close(); };
  // Calibration constants stuff
  void setInitialConstants( CalibrationConstants* constants ) { m_constantsInit = constants; };
  void setFinalConstants( CalibrationConstants* constants ) { m_constantsFinal = constants; };  
  CalibrationConstants* getInitialConstants() { return m_constantsInit; };
  CalibrationConstants* getFinalConstants() { return m_constantsFinal; };
  // Minimization
  void configure( TString );
  int calibrate();
  ClassDef( Calibrator , 1 );
};


void (Calibrator::*fMinimizer)( Int_t&, Double_t*, Double_t&, Double_t*, Int_t ) = NULL;

Calibrator* fCalibrator = NULL;


// double pionmass = 134.9766;
// 
// typedef std::map< int ,float > CalibrationTable;
// 
// void CWrapCalculate(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag); // the "real" funtion
// 
// class CalibrationConstants{
// private:
//   CalibrationTable m_table;
//   float           m_prsConst;
// public:
//   CalibrationConstants() {};
//   CalibrationConstants( TString );
//   void load( TString );
//   float param( int );
//   float prsConstant();
// };
// 
// CalibrationConstants::CalibrationConstants( TString filename )
// {
//  load( filename );
// }
//  
// void CalibrationConstants::load( TString filename )
// {
//   std::ifstream file( filename );
//   if( file ){
//     std::string line , prsName; 
//     std::getline( file, line );
//     std::istringstream is( line );
//     float param;
//     is >> prsName;
//     is >> param;
//     m_prsConst = param;    
//   }
//   while ( file ){
//     std::string line;  
//     std::getline( file, line );
//     std::istringstream is( line );
//     int cellId;
//     float param;
//     is >> cellId;
//     is >> param;
//     m_table[ cellId ] = param;
//   }
// }
// 
// float CalibrationConstants::param( int id )
// { 
//   std::map<int,float>::iterator it = m_table.find( id );
//   if ( it == m_table.end() ) { return 1.0; }
//   else { return it->second; }
// }
// 
// float CalibrationConstants::prsConstant()
// {
//   std::map<int,float>::iterator it = m_table.find( 0 );
//   if ( it == m_table.end() ) { return 11.0; }
//   else { return m_prsConst; }
// }
// 
// 
// class Cluster{
// private:
//   int m_cellID;
//   float m_e;
//   float m_ePrs;
//   void setCellID( int cellID ){ m_cellID = cellID; }
//   void setE( float e ){ m_e = e; }
//   void setEPrs( float ePrs ){ m_ePrs = ePrs; }
// public:
//   Cluster(){};
//   Cluster( int , float , float );
//   int cellID(){ return m_cellID; }
//   float e(){ return m_e; }
//   float ePrs() { return m_ePrs; }
// };
// 
// class Pion{
// private:
//   Cluster m_cluster1;
//   Cluster m_cluster2;
//   float m_cosPhi;
//   void setClusters( Cluster c1 , Cluster c2 ){ m_cluster1 = c1; m_cluster2 = c2; }
//   void setCosPhi( float cosPhi ){ m_cosPhi = cosPhi; }
// public:
//   Pion(){};
//   Pion( Cluster , Cluster , float );
//   std::vector<Cluster> clusters(){
//     std::vector<Cluster> clus;
//     clus.push_back( m_cluster1 );
//     clus.push_back(m_cluster2 );
//     return clus;
//   }
//   float cosPhi(){ return m_cosPhi; }
// };
// 
// Cluster::Cluster( int cellID , float e , float ePrs ){
//   setCellID( cellID );
//   setE( e );
//   setEPrs( ePrs );
// }
// 
// Pion::Pion( Cluster c1 , Cluster c2 , float cosPhi ){
//   setClusters( c1 , c2 );
//   setCosPhi( cosPhi );
// }
// 
// class Calibrator : public TObject {
// private:
//   TFile* file;
//   TTree*                 m_data;
//   TTree*                 m_bkg;
//   int                    m_cellID[2];
//   float                  m_e[2];
//   float                  m_ePrs[2];
//   float                  m_cosPhi;
//   std::vector<Pion*>     m_bkgClus;
//   std::vector<Pion*>     m_dataClus;
//   std::map< int , int >  m_cellIDs;
//   CalibrationConstants*  m_constants;
// public:
//   Calibrator() : m_data(NULL) { m_constants = new CalibrationConstants(); }
//   // Calibrator( TString , TString )
//   void initializeTrees( TString );
//   void initializeConstants( TString );
//   void showCells();
//   void minimize( TString );
//   void setup();
//   void calculate( Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag );
//   
//   ClassDef( Calibrator , 1 );
// };
// Calibrator* gWrapperCalibrator = NULL;