// -------------------------------------------------------------------------
// -----                        CbmMvdClusterFinder source file                   -----
// -----           Created 23.08.2011  by Q. Li, M. Deveaux      -----
// -------------------------------------------------------------------------

#include "CbmMvdClusterFinder.h"
#include "FairLogger.h"

#include <iostream>
#include <vector>
using std::cout;
using std::endl;

// -----   Default constructor   -------------------------------------------
CbmMvdClusterFinder::CbmMvdClusterFinder(): FairTask() {
    
    
    fVerbose=0;
    

}
// -------------------------------------------------------------------------



// -----   Standard constructor   ------------------------------------------
CbmMvdClusterFinder::CbmMvdClusterFinder(const char* name, Int_t iVerbose)
  : FairTask(name){
    fVerbose=iVerbose;
    fInputPersistance=-1;
    


}
// -------------------------------------------------------------------------

InitStatus CbmMvdClusterFinder::Init(){
  
  FairRootManager* ioman = FairRootManager::Instance();
  if ( ! ioman ) {
	cout << "-E- " << GetName() << "::Init: No FairRootManager!" << endl;
	return kFATAL;
    }

  fClusterArray = (TClonesArray*) ioman->GetObject("MimoData");
  if (!fClusterArray) {cout << "test" << endl; 
  Fatal (GetName(), "Could not find cluster, good bye!");}
  fEventNum =0; 
  clusterC = new TCanvas("myC1","A Canvas",10,10,800,600);
  clusterC->Divide(2,3);

  iEvent1TestHisto = new TH1F("ClusterHisto","Event1",100, 0,20);
  iEvent1TestHisto -> GetXaxis()->SetTitle("X:num of pixel in one cluster");
  iEvent1TestHisto -> GetYaxis()->SetTitle("Y:num of cluster ");
  
  iEvent2TestHisto = new TH1F("ClusterHisto","Event2",100, 0,20);
  iEvent2TestHisto -> GetXaxis()->SetTitle("X:num of pixel in one cluster");
  iEvent2TestHisto -> GetYaxis()->SetTitle("Y:num of cluster ");
  
  iEvent3TestHisto = new TH1F("ClusterHisto","Event3",100, 0,20);
  iEvent3TestHisto -> GetXaxis()->SetTitle("X:num of pixel in one cluster");
  iEvent3TestHisto -> GetYaxis()->SetTitle("Y:num of cluster ");
  
  iEvent4TestHisto = new TH1F("ClusterHisto","Event4",100, 0,20);
  iEvent4TestHisto -> GetXaxis()->SetTitle("X:num of pixel in one cluster");
  iEvent4TestHisto -> GetYaxis()->SetTitle("Y:num of cluster ");
  
  iEvent5TestHisto = new TH1F("ClusterHisto","Event5",100, 0,20);
  iEvent5TestHisto -> GetXaxis()->SetTitle("X:num of pixel in one cluster");
  iEvent5TestHisto -> GetYaxis()->SetTitle("Y:num of cluster ");
  
  iRootFile = new TFile("ClusterHist.root","RECREATE");
}


// -------------------------------------------------------------------------


InitStatus CbmMvdClusterFinder::ReInit(){cout << "Hello World Init the ClusterFinder again " << endl;}

//nexts are the test of Qiyan step by step

 
void CbmMvdClusterFinder::ClusterFinder(){
  Int_t iCurrentStateline = 0;
  Int_t iStateline = 0;
  
  Int_t iIndexOfData = 0;
 
  Int_t iRowAddr = 0; 
  Int_t iNewRowAddr = 0;
  
  Int_t iNrOfState = 0;
  Int_t iNewNrOfState = 0;
  
  Int_t iState = 0;
  Int_t iNewState = 0;
  
  Int_t iNumOfCompare = 0;
  Int_t iNewNumOfCompare = 0;
  
  Int_t iNrOfCluster = 0;
  Int_t iNrOfDataLeft = dataLength;
  
  Int_t iNrOfClusterToCompare = 0;
  
  Int_t iIndexofline = 0;
 
  fClustVector.clear();
  fNum.clear();
  fNewNumnew.clear();
  Int_t mynum = 0;
 
  
  
  while(iNrOfDataLeft>0)
  {
    //update the old line information
 
    iRowAddr = iNewRowAddr;
    
    iNumOfCompare = iNewNumOfCompare;
    iNewNumOfCompare = 0;
    
    fNum.clear();
    fNum = fNewNumnew;
    fNewNumnew.clear();

    iNrOfClusterToCompare = fNum.size();
    
    iState = 0;
    iNewState = 0;
    
    iIndexofline = iIndexOfData;
    
    iCurrentStateline = fStateVector[iIndexOfData+1]*256 + fStateVector[iIndexOfData];
    iNewRowAddr = iCurrentStateline % 4096/2;
    iNewNrOfState = iCurrentStateline/4096;
    iNrOfDataLeft = iNrOfDataLeft - (iNewNrOfState + 1);

    
   //compare the state from left to right
    if( fNum.size() == 0 || ((iNewRowAddr - iRowAddr) > 1))
    {
      for(Int_t i=0;i<iNewNrOfState;i++)
      {
	iState = iNewState;
	iIndexOfData = iIndexOfData + 2;
	iNewState = fStateVector[iIndexOfData+1]*256 + fStateVector[iIndexOfData];
	iNrOfCluster = fClustVector.size();
	if ((iNewState/8%2048 - (iState/8%2048 + iState%16384 ))>0)
	{
	  fClustVector.push_back(fIndexOfState);
	  
	  fClustVector[iNrOfCluster].push_back(iNrOfCluster);
	  fClustVector[iNrOfCluster].push_back(iIndexofline);
	  fClustVector[iNrOfCluster].push_back(iIndexOfData );
	  fNewNumnew.push_back(1);
	}
	else
	{
	  fClustVector[iNrOfCluster-1].push_back(iIndexofline);
	  fClustVector[iNrOfCluster-1].push_back(iIndexOfData);
	  Int_t iNum = fNewNumnew.size();
	    fNewNumnew[iNum-1]++;
	 }
      }
    }
    else if((iNewRowAddr - iRowAddr) == 1)
    {
     for(Int_t i=0;i<iNewNrOfState;i++)
      {
	iIndexOfData = iIndexOfData + 2;
	iNewState = fStateVector[iIndexOfData+1]*256 + fStateVector[iIndexOfData];
	iNrOfCluster = fClustVector.size();
	
	for(Int_t j=iNrOfClusterToCompare;j>0;j--)
	{
	  Int_t num1 = fClustVector[iNrOfCluster - j].size();
	  for(Int_t m=fNum[iNrOfClusterToCompare - j];m>0;m--)
	  {
	    
	    Int_t num2 = fClustVector[iNrOfCluster - j][num1 - 2*m + 1];
	    iState = fStateVector[num2 + 1]*256 + fStateVector[num2];
	    iNrOfCluster = fClustVector.size();
	 
	    
	    if (((iNewState/8%2048 +iNewState/16384 + 1) >iState/8%2048 ) && (iNewState/8%2048 < (iState/8%2048 + iState/16384 +1)))
	    {
 	      fClustVector[iNrOfCluster - j].push_back(iIndexofline);
 	      fClustVector[iNrOfCluster - j].push_back(iIndexOfData);
 	      fNewNumnew.push_back(1); 
	      fNum[iNrOfClusterToCompare - j]++;
	      m = 0;
	      //update the new cluster
	      fTempCluster.clear();
	      fTempCluster = fClustVector[iNrOfCluster - j];
	      Int_t iNumOfLoop = fClustVector.size(); 
	      for(Int_t t = iNrOfCluster - j;t<(iNumOfLoop-1);t++)
	      {
		fClustVector[t].clear();
		fClustVector[t] = fClustVector[t+1];
	      }
	      fClustVector[iNumOfLoop -1] = fTempCluster;
	      
	      Int_t iTempNum = 0;
	      iTempNum = fNum[iNrOfClusterToCompare - j];
	      
	      iNumOfLoop = fNum.size();
	      
	      for(Int_t t = iNrOfClusterToCompare - j;t<(iNumOfLoop-1);t++)
	      {
		fNum[t] = fNum[t+1];
	      }
	      fNum[iNumOfLoop -1] = iTempNum;
	    }
	    
	    else if(m ==1)
	    {
	      fClustVector.push_back(fIndexOfState);
	     
	      fClustVector[iNrOfCluster].push_back(iNrOfCluster);
	      fClustVector[iNrOfCluster].push_back(iIndexofline);
	      fClustVector[iNrOfCluster].push_back(iIndexOfData );
	      fNewNumnew.push_back(1);
	      fNum.push_back(1);
	    }

	 }
	}
      }
     }
  
     
     iIndexOfData = iIndexOfData + 2; 
  }
 
 cout<<"In this frame the cluster number is  "<<fClustVector.size()<<endl;
//      for(Int_t m =0;m<fClustVector.size();m++)
// 	  {
// 	    cout <<"the " << m << " cluster including such states:"<<endl;
// 	    for(Int_t j=1;j<fClustVector[m].size();j++)
// 	    {
// 	      cout << fClustVector[m][j] << " ";	
// 	    }
// 	    cout <<endl;
// 	  }
}


//draw the diatribution map of cluster based on state

void CbmMvdClusterFinder::StateInClusterHisto(void)
{
  
  Int_t fClusterArray[10];
  for(Int_t j=0;j<10;j++)
  {
    fClusterArray[j] = 0;
  }
  
  Int_t numOfCluster = fClustVector.size();
  for(Int_t i=0;i<fClustVector.size();i++)
  {
    if((fClustVector[i].size()-1)/2 > 10)
      cout << "one is bigger!"<<endl;
    else
      fClusterArray[(fClustVector[i].size()-1)/2-1]++;
      
  }
 
  for(Int_t j=0;j<10;j++)
  {
    cout << fClusterArray[j] <<" ";
    fStateNumForTest = fStateNumForTest + fClusterArray[j]*(j+1);
    switch(fEventNum)
    {
      case 1:iEvent1TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 2:iEvent2TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 3:iEvent3TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 4:iEvent4TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 5:iEvent5TestHisto->Fill(j+1, fClusterArray[j]);break;
    }
  }
  clusterC->cd(fEventNum);
  switch(fEventNum)
  {
    case 1:iEvent1TestHisto->Draw();break;
    case 2:iEvent2TestHisto->Draw();break;
    case 3:iEvent3TestHisto->Draw();break;
    case 4:iEvent4TestHisto->Draw();break;
    case 5:{iEvent5TestHisto->Draw();
	    clusterC->SaveAs("cluster distribution.gif");
	    iRootFile->cd();
	    clusterC->Write();
	    break;
            }
   }
 }
 
//draw the diatribution map of cluster based on pixel

void CbmMvdClusterFinder::PixelInClusterHisto(void)
{
  Int_t sumOfPixelInCluster = 0;
  Int_t indexOfState = 0;
  Int_t fClusterArray[17];
  for(Int_t j=0;j<17;j++)
  {
    fClusterArray[j] = 0;
  }
  
  Int_t numOfCluster = fClustVector.size();
  
  for(Int_t i=0;i<fClustVector.size();i++)
  {
  sumOfPixelInCluster = 0;
   for(Int_t j=1;j<=fClustVector[i].size()/2;j++)
   {
     indexOfState = fClustVector[i][2*j];
     sumOfPixelInCluster = sumOfPixelInCluster + fStateVector[indexOfState+1]/64;
   }
   if(sumOfPixelInCluster > 16)
   {
     cout <<"the number of pixel in one cluster is bigger than 16 is "<< sumOfPixelInCluster <<endl;
     fClusterArray[16]++;
   }
   else
     fClusterArray[sumOfPixelInCluster]++;
  }
  
     
  for(Int_t j=0;j<17;j++)
  {
    cout << fClusterArray[j] <<" ";
    switch(fEventNum)
    {
      case 1:iEvent1TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 2:iEvent2TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 3:iEvent3TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 4:iEvent4TestHisto->Fill(j+1, fClusterArray[j]);break;
      case 5:iEvent5TestHisto->Fill(j+1, fClusterArray[j]);break;
    }
  }
  clusterC->cd(fEventNum);
  switch(fEventNum)
  {
    case 1:iEvent1TestHisto->Draw();break;
    case 2:iEvent2TestHisto->Draw();break;
    case 3:iEvent3TestHisto->Draw();break;
    case 4:iEvent4TestHisto->Draw();break;
    case 5:{iEvent5TestHisto->Draw();
	    clusterC->SaveAs("cluster distribution.gif");
	    iRootFile->cd();
	    clusterC->Write();
	     break;
            }
   }
 }
  



void CbmMvdClusterFinder::Exec(Option_t* opt){
 
  cout << "Hello World Exec " << endl;
  fEventNum ++;
  
  Int_t num=0;
  num = fClusterArray->GetEntries();// to get the index of entry
  fMimodata = (CbmMvdMimoData*)fClusterArray->At(num-1);
  if (fMimodata == NULL)
    cout << "ZERO POINTER "<< endl;
    
  fStateVector.clear();
  fMimodata->GetState(fStateVector);//Store the useful data into fStateVector 
  frameCounter = fMimodata->GetFrameID();
  dataLength = fMimodata->GetDatalength();
  Int_t fStateNum = fMimodata->GetStateNum();
  cout<<"num is "<< fStateNum <<endl;
  
  ClusterFinder();
  StateInClusterHisto();
  if (fStateNumForTest == fStateNum)
    cout<<"Go home to have a nice supper :)"<<endl;
  else
    cout<<"Go back to check~"<<endl;
  
 // PixelInClusterHisto();

  
  
   // -----   Timer   --------------------------------------------------------
    TStopwatch timer;
    timer.Start();
   // ClusterFinder();
    timer.Stop();
    Double_t rtime = timer.RealTime();
    Double_t ctime = timer.CpuTime();
    cout<< "the realtime of cluster is "<<rtime<<" and the CpuTime is "<<ctime<<endl;

}






void CbmMvdClusterFinder::Finish()
{
   cout<<"End..."<<endl;
}
  


// -----   Destructor   ----------------------------------------------------
CbmMvdClusterFinder::~CbmMvdClusterFinder() { }
// -------------------------------------------------------------------------

ClassImp(CbmMvdClusterFinder)