#include "TH1I.h"
#include "TProfile.h"

#include "TFile.h"
#include "TTimeStamp.h"

#include "stdlib.h"
#include <iostream>
#include <string>
#include <map>




#define NUM_ELEMENTS(aname) (sizeof(aname)/sizeof(aname[0]))

namespace test{

  // constants controlling the key 
  // parameters of the test programme: 

  // pixel matrix dimensions: 
  const unsigned short ROW_COUNT=45; 
  const unsigned short COL_COUNT=40; 

  // number of charges
  const unsigned short CHARGE_COUNT=14;


  // number of phases 
  const unsigned short PHASE_COUNT=1;  
  
  // number of 
  const int FILL_LOOP_COUNT=100000;




  
  //
  // a 2-D pixel address
  //
  class pixel_address{
  public: 
    pixel_address(int rnd=0):mRow(0),mCol(0){if(rnd){this->Rnd();}}
    pixel_address(const pixel_address & addr):mRow(addr.mRow),mCol(addr.mCol){}
   
    int operator<(const pixel_address & rhs)const{
      if(this==&rhs){return 0;}
      if(mCol<rhs.mCol){return 1;}
      if(mCol==rhs.mCol && mRow<rhs.mRow){return 1;}
      return 0; 
    }
    int operator==(const pixel_address & rhs)const{
      if(this==&rhs){return 1;}
      if(mCol==rhs.mCol && mRow==rhs.mRow){return 1;}
      return 0; 
    }
    
    // 10 x 10 pixel array:
    int Rnd(){mRow=(rand()%ROW_COUNT);mCol=(rand()%COL_COUNT);}
    
    unsigned short mRow; 
    unsigned short mCol; 
  };
  
  //
  // map of charge index to histogram:
  //
  class charge_map{
  public: 

    charge_map(const pixel_address & addr, const std::string & name):mAddr(addr), mName(name){}
    ~charge_map(){
      std::map<unsigned short, TH1I * >::iterator it=mQMap.begin();
      std::map<unsigned short, TH1I * >::iterator end=mQMap.end();
      while(it!=end){delete it->second;it->second=0;++it;}
      mQMap.clear(); 
    } 
    
    TH1I * Histogram(unsigned short qidx){
      TH1I * temp=0; 
      //std::cout<<"mQMap.size() = "<<mQMap.size()<<std::endl;
      std::map<unsigned short, TH1I *>::iterator it=mQMap.find(qidx);   
      if(mQMap.end()==it){
	
	if(0){
	  std::cout<<"charge index not found: "
		   <<qidx<<": instantiating histogram "
		   <<mName<<":"<<mAddr.mCol<<","<<mAddr.mRow<<std::endl;
	}
	
	char name[256];
	snprintf(name, NUM_ELEMENTS(name)-1, "histo_%s_%d_%d_%d", mName.c_str(), mAddr.mCol, mAddr.mRow, qidx); 
	char title[256];
	snprintf(title, NUM_ELEMENTS(title)-1, "%s for pixel %d,%d, Q=%d", mName.c_str(), mAddr.mCol, mAddr.mRow, qidx); 
	temp=new TH1I(name, title, 500, -0.5, 500.5);
	// and insert:
	mQMap[qidx]=temp;
      }else{
	temp=it->second; 
      }

      return temp; 
    } 
    
    
    int WriteResults(TDirectory * d){
      std::map<unsigned short, TH1I *>::iterator it=mQMap.begin(); 
      std::map<unsigned short, TH1I * >::iterator end=mQMap.end();
      d->cd(); 
      while(it!=end){
	it->second->Write(); 
	++it;
      }
      return 0; 
    } 
    
  private: 
    std::string mName;
    pixel_address mAddr; 
    std::map<unsigned short, TH1I *> mQMap;   
  };

  
  //
  // The set of histograms for a pixel: 
  //   T1 : a map of the time of discriminator leading edge to the charge injected
  //   T2 : a map of the time of discriminator trailing edge to the charge injected
  //   TOT: a map of the time of discriminator time over threshold to the charge injected
  // 
  class pixel_histograms{
  public: 
    pixel_histograms(const pixel_address & addr):
      mAddr(addr),
      mT1(addr, "T1"), 
      mT2(addr, "T2"), 
      mTOT(addr, "TOT")
    {
    }
    

    int Fill()
    {
      for(unsigned short qidx(0); qidx!=CHARGE_COUNT; qidx++){
	//std::cout<<"filling for charge index = "<<qidx<<std::endl;
	//std::cout<<"filling for pixel = "<<mAddr.mCol<<","<<mAddr.mRow<<std::endl;

	// just fill with numbers for this test:
	TH1I * temp=0; 
	temp=mT1.Histogram(qidx);
	temp->Fill((rand()%100)+10);
	
	temp=mT2.Histogram(qidx);
	temp->Fill((rand()%100)+200);
	
	temp=mTOT.Histogram(qidx);
	temp->Fill(rand()%100);
      }      
      return 0; 
    }

    int WriteResults(TDirectory * d){
      TDirectory * sd=0; 
      
      // write out for T1: 
      d->cd();       
      sd=d->mkdir("T1"); 
      if(!sd){
	std::cerr<<"unable to create sub-directory: T1\n";
      }else{
	mT1.WriteResults(sd); 
      }
      
      // write out for T2: 
      d->cd(); 
      sd=d->mkdir("T2"); 
      if(!sd){
	std::cerr<<"unable to create sub-directory: T2\n";
      }else{
	mT2.WriteResults(sd); 
      } 
      
      // Write out for TOT:
      d->cd(); 
      sd=d->mkdir("TOT"); 
      if(!sd){
	std::cerr<<"unable to create sub-directory: TOT\n";
      }else{
	mTOT.WriteResults(sd); 
      }
      
      return 0; 
    }

  private: 
    pixel_address mAddr; 
    charge_map mT1; 
    charge_map mT2; 
    charge_map mTOT; 
  };


  // 
  // the histograms for the pixel array
  // 
  //
  class matrix_histograms{
  public: 
    matrix_histograms(){}
    
    ~matrix_histograms(){// owns everything pointed to: clean-up
      std::map<pixel_address, pixel_histograms *>::iterator it=mMatrix.begin(); 
      std::map<pixel_address, pixel_histograms *>::iterator e=mMatrix.end(); 
      while(it!=e){delete it->second; it->second=0;++it;}
      mMatrix.clear(); 
    }
    
    pixel_histograms * Pixel(const pixel_address & addr){
      pixel_histograms * temp=0; 
      std::map<pixel_address, pixel_histograms *>::iterator it=mMatrix.find(addr);
      if(it==mMatrix.end()){// not yet instanced: construct and insert 
	std::cout<<"pixel histograms not found, creating new ones: "<<addr.mCol<<","<<addr.mRow<<std::endl;
	temp=new pixel_histograms(addr); 
	mMatrix[addr]=temp; 
      }else{// pixel seen before: cache the ptr
	temp=it->second;
      }
      return temp; 
    }
    
    int WriteResults(TDirectory * d){
      std::map<pixel_address, pixel_histograms *>::iterator it=mMatrix.begin(); 
      std::map<pixel_address, pixel_histograms *>::iterator e=mMatrix.end(); 
      while(it!=e){
	char dname[256];
	snprintf(dname, NUM_ELEMENTS(dname)-1, "pixel_%d_%d",it->first.mCol,it->first.mRow); 
	d->cd(); 
	TDirectory * sd=d->mkdir(dname); 
	if(!sd){
	  std::cerr<<"unable to create sub-directory: "<<dname<<"\n";
	}else{
	  it->second->WriteResults(sd);
	}

	++it;
      }
    } 

  private:
    std::map<pixel_address, pixel_histograms *> mMatrix;
  };








  //
  // a test "analysis" class 
  // 
  //
  //
  //
  class analysis{
  public:
    analysis():mOutputFile("histos.root"){
      
      TFile * fout=TFile::Open("histos.root", "RECREATE"); 
      if(fout){
	fout->Close();delete fout;fout=0;
      }else{/*a problem*/
	std::cerr<<"unable to recreate file : "<<mOutputFile<<"\n";
      }
      TH1::AddDirectory(kFALSE); 
    }



    int Analyse(){
      int rv=0; 
      
      for(unsigned short phase(0); phase!=PHASE_COUNT; phase++){
	matrix_histograms * pmh=new matrix_histograms();
	
	for(int idx(0); idx!=FILL_LOOP_COUNT; idx++){
	  if((idx%10000)==0){std::cout<<"Phase : "<<phase<<", idx = "<<idx<<std::endl;}

	  pixel_address addr(1);// select random pixel
	  pixel_histograms * ph=pmh->Pixel(addr); 
	  
	  // Fill operation
	  ph->Fill(); 
	  
	}
	
	rv=this->WriteResults(phase, pmh); 
	if(rv){std::cerr<<"a problem occurred during WriteResults()\n";return -1;}
	
	delete pmh; 
	pmh=0; 
      
      }
      std::cout<<__PRETTY_FUNCTION__<<": Main loop done"<<std::endl;
      return 0;
    }


    
  private: 

    int WriteResults(unsigned short phase,  matrix_histograms * h)
    {
      
      TTimeStamp start_time;

      TFile * fout=TFile::Open(mOutputFile.c_str(), "UPDATE"); 
      if(!fout){std::cerr<<"unable to open file for updating: "<<mOutputFile<<". Nothing will be written\n";return -1;}
      
      char dirname[256];snprintf(dirname, NUM_ELEMENTS(dirname)-1, "phase_%d",phase); 
      TDirectory * d=fout->mkdir(dirname); 
      if(!d){
	std::cerr<<"unable to create directory: "<<dirname<<"\n";
      }else{
	h->WriteResults(d); 
      }
      TTimeStamp write_done;
      fout->Flush(); 
      TTimeStamp flush_done;

      fout->Close(); 
      TTimeStamp close_done;
      delete fout; fout=0; 
      TTimeStamp delete_done;
      
      std::cout<<"time to write = "<<write_done.AsDouble()-start_time.AsDouble()<<"s"<<std::endl;
      std::cout<<"time to flush = "<<flush_done.AsDouble()-write_done.AsDouble()<<"s"<<std::endl;
      std::cout<<"time to close = "<<close_done.AsDouble()-flush_done.AsDouble()<<"s"<<std::endl;
      std::cout<<"time to delete = "<<delete_done.AsDouble()-close_done.AsDouble()<<"s"<<std::endl;
      
      return 0; 
    }



    std::string mOutputFile; 

  };
}

int main()
{
  int rv=0; 
  test::analysis a;
  std::cout<<"starting Analyse()"<<std::endl;
  rv=a.Analyse(); 
  if(rv){std::cerr<<"a problem occurred during Analyse()\n";return -1;}
  std::cout<<"Analyse() completed"<<std::endl;

  return 0;
}