#include<iostream>
#include<sstream>
#include<string>

#include "TStyle.h"
#include "TFile.h"
#include "TTree.h"
#include "TVector3.h"
#include "TApplication.h"
#include "TObject.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TF1.h"


#include "dataReader.h"
#include "tracking.h"
#include "Config.h"
#include "Pedestals.h"
#include "Calib.h"
#include "ConfigFile.h"

#include "TpcSample.h"
#include "TpcPSAplot.h"
#include "TpcSimplePSAStrategy.h"
#include "TpcPSA_TOT1.h"
#include "TpcDigiMapper.h"
#include "TpcCluster.h"
#include "TpcClusterFinder.h"
#include "TpcClusterFinderSimple.h"

#include "AnalysisCluster.h"
#include "AnalysisEvent.h"

using namespace std;



void failedConf(std::string);

int main(int argc, char* argv[]) {


  AnalysisEvent *outputEvent = new AnalysisEvent();

  if(argc != 4) {
	cerr << "NumArgs is not 3" << endl;
	throw;
  }

  string infile(argv[1]);
  string outfile(argv[2]);
  string conffile(argv[3]);
  std::cout << "Opening config file..." << std::endl;
  ConfigFile cf( conffile.c_str() );

  Calib::getInstance()->setKey(infile);
  std::string pedFileName(Calib::getInstance()->get_pedFile());
  new Pedestals(pedFileName);
  std::map<int,double> ped_m;
  std::map<int,double> ped_s;
  Pedestals::getPedestals(ped_m,ped_s);
  
//   for(int i=0;i<128;++i) {
// 	cout << i << " " << ped_m[i] << " " << ped_s[i] << endl;
//   }
  


  Calib* calib = Calib::getInstance();


  TFile* file = TFile::Open(infile.c_str());
  if(file == NULL) {
	cerr << "Input file couldn't be loaded -> abort" <<endl;
	throw;
  }

  TTree* intree = (TTree*)file->Get("datatree_m");
  if(intree == NULL) {
	cerr << "Tree couldn't be loaded -> abort" <<endl;
	throw;
  }





  //TpcAbsPSAStrategy*_psa= new TpcSimplePSAStrategy(10); // threshold (in adc channels)

  TpcAbsPSAStrategy*_psa= new TpcPSA_TOT1();
  

  dataReader myReader(intree);

  TCevt* event;
  McId dummyID(1,1);

  TApplication theApp("myApp",NULL,NULL);

  gROOT->Macro("macro/christian_style.C");

  /*
  gROOT->SetStyle("Plain");
  gStyle->SetTitleFont(102);
  gStyle->SetTitleOffset(1.3,"Y");
  gStyle->SetTitleFont(102,"Y");
  gStyle->SetLabelFont(102);
  //  gStyle->SetLabelOffset(.01);
  gStyle->SetTitleOffset(1.2);
  gStyle->SetLabelSize(0.035);
  gStyle->SetLabelSize(0.035,"Y");
  gStyle->SetLabelFont(102,"Y");
  */

  TpcDigiMapper* mapper = TpcDigiMapper::getInstance();

  std::vector<TpcDigi*> digis;

  int clust_choice;  
  int timewindow_chr,timewindow_seb;
  if(!(cf.readInto(clust_choice , "CLUSTERING") )) failedConf("CLUSTERING");
  if(!(cf.readInto( timewindow_chr, "TIMEWINDOW_CLUST_CHR") )) failedConf("TIMEWINDOW_CLUST_CHR");
  if(!(cf.readInto( timewindow_seb, "TIMEWINDOW_CLUST_SEB") )) failedConf("TIMEWINDOW_CLUST_CHR");

  std::vector<TpcCluster*> *clusters = new std::vector<TpcCluster*>;
  TpcAbsClusterFinder *clusterfinder;
  if(clust_choice == 0 || clust_choice == 1) {
	clusterfinder = new TpcClusterFinderSimple(TpcDigiMapper::getInstance()->getPadPlane(),clusters,timewindow_chr);
  }
  else {
	if(clust_choice == 2) {
	  clusterfinder = new TpcClusterFinder(TpcDigiMapper::getInstance()->getPadPlane(),clusters,timewindow_seb);
	}
	else {
	  std::cerr << "Wrong value for clusterfinder was given ->abort" << std::endl;
	  throw;
	}
  }
  clusterfinder->checkConsistency();
  //  clusterfinder->setTrivialClustering();

  std::vector<TpcCluster*> *clusters_trivial = new std::vector<TpcCluster*>;


  
  double ellipse_ay,ellipse_by;
  int minselhits,visflag;
  if(!(cf.readInto( ellipse_ay, "ELLIPSE_AY") )) failedConf("ELLIPSE_AY");
  if(!(cf.readInto( ellipse_by, "ELLIPSE_BY") )) failedConf("ELLIPSE_BY");
  if(!(cf.readInto( minselhits, "MINSELHITS") )) failedConf("MINSELHITS");
  if(!(cf.readInto( visflag, "VISFLAG") )) failedConf("VISFLAG");

  double trackMargin;
  if(!(cf.readInto( trackMargin, "TRACKMARGIN") )) failedConf("TRACKMARGIN");
  if(trackMargin>35) {
	std::cerr << "A track margin >35mm doesnt make sense ->abort" << std::endl;
	throw;
  }

  tracking *mytracking = new tracking(visflag,ellipse_ay,ellipse_by,minselhits,trackMargin,true,"clust_with_halt");
  tracking *mytracking2 = new tracking(visflag,ellipse_ay,ellipse_by,minselhits,trackMargin,false,"trivial_without_halt");

  TFile* rootOutfile = new TFile(outfile.c_str(),"RECREATE");
  rootOutfile->cd();
  TTree* analysisTree = new TTree("at","TPC test chamber analysis tree");
  analysisTree->Branch("EventBranch","AnalysisEvent",&outputEvent,32000,99);


  while(1) {
	event = myReader.readEvent();
	if(event == NULL) {
	  break;
	}
	if( event->Nchan(ped_s) > 64) {
	  std::cout << "more than 64 pads fired -> skipping" << std::endl;
	  continue;
	}
	//	event->Print(10);
	cout << "Processing Event with trigger ID: " << event->trigger << endl;

	int maxtrigger;
	if(!(cf.readInto( maxtrigger, "MAXTRIGGER") )) failedConf("MAXTRIGGER");
	if(event->trigger>maxtrigger)break;

	//clean up
	for(unsigned int i=0;i<digis.size();i++) {
	  delete digis.at(i);
	}

	digis.clear();
	for(unsigned int i=0;i<clusters->size();i++) {
	  delete clusters->at(i);
	}
	clusters->clear();
	clusterfinder->reset();

	for(unsigned int i=0;i<clusters_trivial->size();i++) {
	  delete clusters_trivial->at(i);
	}
	clusters_trivial->clear();
	//	clusterfinder2->reset();

	//Pulse Shape Analysis
	for(int iPad=0;iPad<128;iPad++) {
	  
	  //make TpcSamples for signals in event tree
	  std::vector<TpcSample*> samplelist;
	  int nsamp=0;
	  for(int iSample=0;iSample<150;iSample++) {
		if(event->time[iPad][iSample]>0 && 
		   event->charge[iPad][iSample] < 100000 && 
		   event->charge[iPad][iSample]>=0) {
		  TpcSample* aSample = new TpcSample(event->time[iPad][iSample],event->charge[iPad][iSample],iPad,dummyID);
		  samplelist.push_back(aSample);
		  if(event->charge[iPad][iSample] > ped_s[iPad]*4.) nsamp++;
		}
	  }



	  if(nsamp>3) {
		_psa->Process(samplelist,digis,ped_s[iPad]*4.);	 
		std::ostringstream mytitle;
		mytitle << "Pulse Shape Analysis -- padID " << iPad;
		TpcPSAplot myplot(&samplelist,&digis,NULL,NULL,mytitle.str());
		int psaplot;
		if(!(cf.readInto( psaplot, "PSAPLOT") )) failedConf("PSAPLOT");
		if(psaplot) myplot.Draw();
	  }
	  //clean up
	  for(unsigned int i=0;i<samplelist.size();i++) {
		delete samplelist.at(i);
	  }
	  samplelist.clear();
	} // end of PSA


	//Clustering (at the moment: one cluster per pad and digi)
	
	for(unsigned int i=0;i<digis.size();i++) {
	  TVector3 pos;
	  mapper->map(digis[i],pos);

	  //this block is define the z jitter
	  TVector3 zDiff1,zDiff2;
	  McIdCollection mcid;
	  mcid.AddID(dummyID);
	  TpcDigi zDiffDigi1(1,1,1,mcid),zDiffDigi2(1,2,1,mcid);
	  mapper->map(&zDiffDigi1,zDiff1);
	  mapper->map(&zDiffDigi2,zDiff2);
	  double zDiff = zDiff2.z() - zDiff1.z();
	  //end of z jitter

	  double Dl = TpcDigiMapper::getInstance()->getGas()->Dl();
	  double Dt = TpcDigiMapper::getInstance()->getGas()->Dt();

	  double diffSigmaL = Dl * sqrt(pos.z());
	  double diffSigmaT = Dt * sqrt(pos.z());
	  double sigmaX_sq = 0.62*0.62/12. + diffSigmaT*diffSigmaT;
	  double sigmaY_sq = 0.1*0.1/12. + diffSigmaT*diffSigmaT;
	  double sigmaZ_sq = zDiff*zDiff/12. + diffSigmaL*diffSigmaL;
	  TVector3 err(sqrt(sigmaX_sq),sqrt(sigmaY_sq),sqrt(sigmaZ_sq));
	  TpcCluster* aCluster = new TpcCluster(pos,err,digis[i]->amp(),i);
	  clusters_trivial->push_back(aCluster);
	}
	
	//done with clustering
	clusterfinder->process(digis);
	int nclust = clusters->size();


	std::cout << "##################" << std::endl;
	std::cout << "Event Statistics" << std::endl;
	int clustersizes=0;
	for(unsigned int i=0;i<clusters->size();++i) {
	  clustersizes += clusters->at(i)->size();
	}
	std::cout << "From clusters: " << clustersizes << " digis" << endl;
	std::cout << "Directly: " << digis.size() << "digis" << endl;
	std::cout << "##################" << std::endl;
	
	AnalysisEvent* dummyEvent = new AnalysisEvent;
	outputEvent->clear();
	//make hit graphs and also hot graphs
	int tracking_wo_clust;
	if(!(cf.readInto( tracking_wo_clust, "TRACKING_WITHOUT_CLUSTERING") )) failedConf("TRACKING_WITHOUT_CLUSTERING");
	if(tracking_wo_clust) mytracking2->processEvent(clusters_trivial,event->trigger,dummyEvent);
	bool success;
	if(clust_choice == 0) {//trivial clustering
	  success = mytracking->processEvent(clusters_trivial,event->trigger,outputEvent);
	}
	else {//other clustering
	  success = mytracking->processEvent(clusters,event->trigger,outputEvent);
	}
	delete dummyEvent;
	if(success) {
	  cout<<"#########################################################################################################################################################################################"<<endl;
	  rootOutfile->cd();
	  analysisTree->Fill();
	}
  }// event loop
  //  delete mytracking;
  //  delete mytracking2;
  rootOutfile->cd();
  analysisTree->Write();
  rootOutfile->Close();



}


void failedConf(std::string var) {
  std::cerr << "Reading parameter " << var << " from conf file failed ->abort"
			<< std::endl;
  throw;
}