#include "TFile.h"
//#include "TTree.h"
//#include "TBrowser.h"
//#include "TH2.h"
//#include "TRandom.h"
#include "TCanvas.h"
#include "TH1F.h"
//#include "TMath.h"
//#include "TROOT.h"
#include <string>
#include <iostream>
#include <sstream>

Double_t myFullFitFunction(Double_t *x, Double_t *par)
{
    //     par(0) -> asymptotic efficiency
    //     par(1) -> HV of 50% of asymptotic efficiency 
    //     par(2) -> HV of 90% - HV of 10% of asymptotic efficiency 
    //    Double_t plat=par[0]/( 1.+ 81.**( (par[1]-x[0])/par[2] ) );
  Double_t value = par[0]+par[1]*exp(-x[0]/par[2])+par[3]*exp(-x[0]/par[4]);
    return value;
}

double calibratedADC_v100x1000_12db(float adc_cout)
{
  return -0.62 + 0.011*adc_cout;
}

void example(int binsInGroup=1, int binsInGroupT=1)
{

  gStyle->SetOptFit(kFALSE);
  //std::string fileNameString = "exampleOutput_testSS.dat";
  //std::string fileNameString = "calibrazione_tac200x1000_0_130.dat";        // 130.0 ns +/- 0.4
  //std::string fileNameString = "calibrazione_tac200x1000_0_600.dat";          // 600 +/ 0.2        
  //std::string fileNameString = "calibrazione_tac200x1000_1_004.dat";        // 1.004 +/- 0.001
  //std::string fileNameString = "calibrazione_tac200x1000_1_02.dat";         // 623.9 media 
  //std::string fileNameString = "calibrazione_tac200x1000_1_03.dat";        // 245.3 media 
  //std::string fileNameString = "calibrazione_tac200x1000_1_49.dat";         // 1.49 
  //std::string fileNameString = "calibrazione_tac200x1000_2_35.dat";         
  //std::string fileNameString = "calibrazione_tac200x1000_3_02.dat";         
  //std::string fileNameString = "calibrazione_tac200x1000_4_27.dat";         
  //std::string fileNameString = "calibrazione_tac200x1000_5_46.dat";
  //std::string fileNameString = "calibrazione_tac200x1000_6_50.dat";
  //std::string fileNameString = "calibrazione_tac200x1000_7_46.dat";
  //std::string fileNameString = "calibrazione_tac200x1000_3.2total.dat";
  //std::string fileNameString = "data_200x1000_20160519.dat_01";
  //std::string fileNameString = "data_200x1000_deadtime1s_20160519.dat";
  //std::string fileNameString = "data_200x1000_deadtime0s_LS5off_20160520.dat";
  //std::string fileNameString = "data_200x1000_deadtime0s_LS6off_20160520.dat";
  //std::string fileNameString = "data_200x1000_deadtime0s_allOn_20160523_tryagain.dat";
  //std::string fileNameString = "data_200x1000_allOn_20160524_prova.dat";
  //std::string fileNameString = "data_100x1000_allOn_20160524_attenuazione6db_calibrazione.dat";
  //std::string fileNameString = "calibrazione_100x1000_attenuzione12db.dat";
  //std::string fileNameString = "data_100x1000_12db.dat";
  //std::string fileNameString = "data_100x1000_12db_LS6off.dat";
  //std::string fileNameString = "data_100x1000_12db_LAYOUT2016-02.dat";
  //  std::string fileNameString = "globalOutputFile_100x1000_12db_LAYOUT2016-02.dat";
  std::string fileNameString = "inputDataFile.dat";
  ifstream inputFile; //abilita la lettura da file 

  TCanvas* cadc[12];
  TH1F* hadc[12];
  std::string htit;
  float adc_min = -0.5;
  float adc_max = 1999.5;
  int nbin_adc = 2000;
  float adc_binw = adc_max-adc_min;
  adc_binw = adc_binw/float(nbin_adc);
  float t_min = calibratedADC_v100x1000_12db(adc_min);
  float t_max = calibratedADC_v100x1000_12db(adc_max);
  int nbin_t = nbin_adc;
  float t_binw = t_max - t_min;
  t_binw = t_binw/float(nbin_t);
  for (int j=0;j<12;++j)
    {
      htit="ADC_channel_";
      ostringstream aa;
      aa<<htit<<j;
      htit = aa.str();
      hadc[j] = new TH1F(htit.c_str(),htit.c_str(),nbin_adc,adc_min,adc_max);
      cadc[j] = new TCanvas(htit.c_str(),htit.c_str(),400,400);
    }

  TH1F* timeH = new TH1F("TimeDistribution","TimeDistribution",nbin_t,t_min,t_max);
  std::cout<<"==================Original Time bin is now "<<timeH->GetNbinsX()<<" /microsec"<<std::endl;

   inputFile.open(fileNameString.c_str());
   if (!inputFile.good()) {cout<<"errore nell'apertura del file "<<fileNameString<<endl; return;} 
   else {std::cout<<"Input file is good !!!"<<std::endl;}

   std::string aLine;
   Int_t evc = 0;
   Int_t evn = 0; 
   Long_t timeSinceJan1970;
   Int_t timeSinceStart, timeSinceLast;
   //   Float_t yp = 0.; Float_t pi = 0; Float_t rt = 0.; Float_t ft = 0.; Float_t ph = 0; Float_t yi = 0.;
   Float_t adc_val[12];
   // skip 7 lines at the start (header)
   //   for (int i=0;i<7;++i) getline(inputFile, aLine);
   std::cout<<"Header is skipped !!!"<<std::endl;
   while (! inputFile.eof() ) 
     {
       
       //std::cout<<" not yet at the end of file"<<std::endl;
       getline(inputFile, aLine);
       if (aLine.empty()) break;
       istringstream aLineStream(aLine);
       std::cout<<"READ <"<<aLine<<">"<<std::endl;
       if (aLine.substr(0,1)=="*") continue; // skip comment 
       aLineStream >> evn >> timeSinceJan1970 >> timeSinceStart >> timeSinceLast;
       for (int j=0;j<12;++j) aLineStream >> adc_val[j];

       //std::cout<<" adc_values = ";
       for (int j=0;j<12;++j) {
	 //std::cout<<" "<<adc_val[j];
	 hadc[j]->Fill( float( adc_val[j] ) );
	 if (j==11) {
	   timeH->Fill( calibratedADC_v100x1000_12db( float( adc_val[j] )) );
	 }
       }
       //       std::cout<<std::endl;
       ++evc;
       if (evc%100==0)
	 {
	   cadc[11]->cd();
	   hadc[11]->Draw();
	   cadc[11]->Update();
	   std::cout<<"n. of lines read so far is  "<<evc<<std::endl;
	   //std::string pippo;
	   //std::cin>>pippo;
	   //if (pippo!="GO") break;
	 }
       //std::cout<<"n. of lines read so far is  "<<evc<<std::endl;
     }
   
   for (int j=0;j<12;++j) 
     {
       cadc[j]->cd();
       hadc[j]->Draw();
     }

      return;
      // end of macro

   TH1F* hADC      = new TH1F(*(hadc[11]));
   TH1F* hADCrebin = new TH1F(*(hadc[11]));
   TCanvas* cfit = new TCanvas("ADC11","ADC11",500,500);
   TCanvas* cfit1 = new TCanvas("ADC11_1","ADC11_1",500,500);
   cfit->cd();
   hADC->Fit("gaus");
   
   Float_t xloweredge = hADC->GetXaxis()->GetXmin();
   Float_t xupperedge = hADC->GetXaxis()->GetXmax();
   Float_t binWidth = hADC->GetBinWidth(1);

   Int_t binWithMaxCont =hADC->GetMaximumBin();
   Float_t xmin = hADC->GetBinCenter(binWithMaxCont)-30*binWidth;
   Float_t xmax = hADC->GetBinCenter(binWithMaxCont)+30*binWidth;


   gStyle->SetOptFit(kTRUE);
   gStyle->SetOptFit(111111);
   //   Float_t xmin = getMinBinNotEmpty(hADC)-10.*binWidth;
   //   Float_t xmax = getMaxBinNotEmpty(hADC)+10.*binWidth;
   if (xmin < xloweredge) xmin = xloweredge;
   if (xmax > xupperedge) xmax = xupperedge;
   Float_t ymax = 1.1*hADC->GetMaximum();
   gPad->DrawFrame(xmin, 0., xmax, ymax);
   hADC->Draw("sames");
   cfit->Update();

   //   gStyle->SetOptFit(kFALSE);
     cfit1->cd();
     hADCrebin->Rebin(binsInGroup);
     hADCrebin->SetMarkerSize(2.);
     hADCrebin->Draw("EP");

     TCanvas* cTime = new TCanvas("cTime","cTime",700,600);
     timeH->Rebin(binsInGroupT);
     timeH->Draw("EP");
     std::cout<<"================== N. of Time bins (after rebinning) now "<<timeH->GetNbinsX()<<std::endl;
     //     std::cout<<"================== Time bin is     (after rebinning) now "<<timeH->GetBinsWidth()<<" /microsec"<<std::endl;

     double lowerLimit = 0.;
     double upperLimit = 15.;
     int npar = 5;
     TF1 *f1 = new TF1("f1",myFullFitFunction,lowerLimit,upperLimit,npar); //3 è il numero dei parametri e tf1 è un oggetto usato per i fit
     f1->SetParName(0,"constant");
     f1->SetParName(1,"normShort");
     f1->SetParName(2,"tauShort");
     f1->SetParName(3,"normLong");
     f1->SetParName(4,"tauLong");
     f1->SetParameter(0,10.);
     f1->SetParameter(1,100.);
     f1->SetParameter(2,.250);
     f1->SetParameter(3,100.);
     f1->SetParameter(4,2.);
     timeH->Fit("f1","R");

}
/*
Float_t getMinBinNotEmpty(TH1F* hADC)
{
}
Float_t getMaxBinNotEmpty(TH1F* hADC)
{
}
*/