////////////////////////////////////
// KRATTA CALIB reader
// for the Asy-Eos experiment
// TKratCalibReader DECLARATION
// Feb 2013
// revison 02/2013
// E.d.F ver 1.0 
// sebastian.kupny@uj.edu.pl
// Changes:
////////////////////////////////////


#ifndef KRATTA_CALIB_READER_H
#define KRATTA_CALIB_READER_H 


#include <iostream>     // std::cout
#include <fstream>      // std::ifstream

#include <map>
#include <string>
#include <vector>

#include "TClonesArray.h"
#include "TF1.h"
#include "TFumili.h"
#include "TGraph.h"
#include "TH1D.h"
#include "TLine.h"
#include "TMarker.h"
#include "TMath.h"

#include "TGeoManager.h"
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "FairTask.h"

//#include "mktreeraw.h"
//#include "mktreecalibchain_sct_fitABC.h"

#include <cstdlib>
#include <iostream>
#include <ctime>
#include <iomanip>


#include "TRootKRATEvent.h"
/*
class  TKratCalibProgressBar : public TNamed
{
  
  private:
    int         fLen;
    Long64_t    fMax;
    char       *fMeter;
    time_t      fStart;
    
    int         fUpdateFrequency;
    
  public:
     TKratCalibProgressBar( int max, int len=20);
     
     int  GetUpdateFrequency(void){  return fUpdateFrequency; };
     void SetUpdateFrequency( unsigned int newUpdateFrequency ){ fUpdateFrequency = newUpdateFrequency;};
     
     void Reset( int max );

     bool UpdateAndWrite(int iev);

  ClassDef(TKratCalibProgressBar,1);    
};
*/


class TKratCalibReader : public FairTask
{

  public:
    /** Default constructor **/  
    //TKratCalibReader();
    
    /** Constructor **/  
    TKratCalibReader (const char* name, TString runlist, Int_t iVerbose = 1);
    //TKratCalibReader(Int_t verbose);

    /** Destructor **/
    ~TKratCalibReader();

    /** Virtual method Init **/
    virtual InitStatus Init();


    /** Virtual method Exec **/
    virtual void Exec(Option_t* opt);
    virtual void Finish();
    virtual void Reset();
    
    void SetVerboseLevel( Int_t verbose ) { 
      fVerbose = verbose;
    }
    Int_t GetVerboseLevel( void ) { 
      return fVerbose;
    }
    
    Long64_t GetNumberOfEventsInInputFiles();
    
    /// KRATTA_IN
    void SetKratContInName( TString KrattaCalibEventFromFileName ){
       fKrattaCalibEventFromFileName = KrattaCalibEventFromFileName;
    }
    TString GetKratContInName( void ) const {
       return fKrattaCalibEventFromFileName;
    }  
    /// KRATTA_OUT
    void SetKratContOutName( TString KrattaCalibEventFromFileCopyName ){
       fKrattaCalibEventFromFileCopyName = KrattaCalibEventFromFileCopyName;
    }
    TString GetKratContOutName( void ) const {
       return fKrattaCalibEventFromFileCopyName;
    }
    /// DOES WRITE OUTPUT DATA CONTAINER TO THE FILE   
    void SaveOutputIntoTree(Bool_t saveOutputToTree = kTRUE){
      fSaveOutputToTree = saveOutputToTree;
    }
    Bool_t DoesSaveOutputIntoTree( void ){
      return fSaveOutputToTree;
    }
    
  protected:
    Long64_t       LoadFilesFromRunlist();
    
    Long64_t       fNumberOfEventsInAllFiles;
    Long64_t       fNumberOfEventsInAnalysedFiles; /// For progress bar only.
        
    TString        fRunlist; 
    
    Int_t          fNFiles;
    Int_t          fCurrentFileNumberOnTheList;
    TString        fInputCalibFileName;
    
    std::vector <TString> fListOfInputFiles;
    
    TFile         *fInputCalibFile;
    TString        fFileMainTreeName; 
    TTree         *fFileMainTree;

    Int_t          fNEventsInTree;
    
    Int_t          fEntryIndex;
    
    Bool_t         fSaveOutputToTree;
    TRootKRATEvent *fKrattaCalibEventFromFile;
    TString         fKrattaCalibEventFromFileName;
    
    TClonesArray   *fKrattaCalibEventFromFileCopy;
    TString         fKrattaCalibEventFromFileCopyName;
    
    TRootKRATParticle *fKrattaParticle;
    TClonesArray      *fKrattaParticleClones;
    //TKratCalibProgressBar * fProgressBar;
    
    /// Returns true if file exist, false otherwise
    bool CheckIfFileExist( const char * filename );
    void GetNextCalibFile();
    
  private:
    TKratCalibReader(const TKratCalibReader&);
    TKratCalibReader& operator=(const TKratCalibReader&){
      return *this;
    }
      
    virtual void SetParContainers();

 
  ClassDef(TKratCalibReader,1);
  
};

#endif ///KRATTA_CALIB_READER_H