// -------------------------------------------------------------------------
// -----                        CbmMvdStringFinder source file                   -----
// -----           Created 28.06.2011  by Q. Li, M. Deveaux      -----
// -------------------------------------------------------------------------

#include "CbmMvdStringFinder.h"
#include "FairLogger.h"

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


// -----   Default constructor   -------------------------------------------
CbmMvdStringFinder::CbmMvdStringFinder(): FairTask() {

  fMimoData = new TClonesArray("CbmMvdMimoData");
  fMimoDataStateMatch = new TClonesArray("CbmMvdMimoStateMatch");
    
    fVerbose=0;
    

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



// -----   Standard constructor   ------------------------------------------
CbmMvdStringFinder::CbmMvdStringFinder(const char* name, Int_t iVerbose)
  : FairTask(name){
    fVerbose=iVerbose;
    fInputPersistance=-1;
    
    fMimoData = new TClonesArray("CbmMvdMimoData");
    fMimoDataStateMatch = new TClonesArray("CbmMvdMimoStateMatch");
}


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

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

  fHitArray = (TClonesArray*) ioman->GetObject("MvdHit");
  fDigiArray= (TClonesArray*) ioman->GetObject("MvdDigi");
  
  
  if (!fHitArray) {cout << "test" << endl; Fatal (GetName(), "Could not find hits, good bye!");}
  if (!fDigiArray){cout << "one more test" << endl; Fatal (GetName(), "Could not find digis, good bye!");}  
 
 //Creat 50 CbmMvdDig* vectors for 50 sensors in one station
  for(Int_t i = 0;i<fMaxNumberOfSensors;i++)
    Array_AT.push_back(fNumDigi);
  
  //board parameters 
  fROCFrame = 1;
  fTimeStamp = 2;
  fSensorOffset = 3;
  fTemp = 4;
  fROCAddress = 5; 
  
  //Mimosa data frame parameters
  fEventNum = 0;
  fHeader0 = 555;
  fHeader1 = 666;
  fFrameCounter0 = 777;
  fFrameConnter1 = 888;
  fDatalength0 = 0;
  fDatalength1 = 0;
  fStateline = 0;
  fStateN = 0;
  fTrailer0 = 1010;
  fTrailer1 = 1010;
   
   fStateNumInOneFrame = 0;
   
   // Create new data class array into the root file to share data
   ioman->Register("MimoData","MVD",fMimoData,kTRUE);
   cout <<"register fMimoData is ok "<<endl;
   
     // Create new data class array into the root file to share data
   ioman->Register("MimoDataStateMatch","MVD",fMimoDataStateMatch,kTRUE);
   cout <<"register fMimoStateMatch is ok "<<endl;
   cout << "Hello World Init " << endl;
  
}


// -------------------------------------------------------------------------
InitStatus CbmMvdStringFinder::ReInit(){cout << "Hello World Init again " << endl;}


//for each sensor : read  x/y coodinater from tree added into Exec() store into the vector :Array_AT
/** Attention :so far the fStationNr only can be set "1" **/
void CbmMvdStringFinder::ReadOfFDigi(Int_t fStationNr ){
  Int_t num_loop = 0;
  Int_t fPixel_X_InStation = 0;
  Int_t fPixel_Y_InStation = 0;
  Int_t fStationNum =0;  
  Int_t fSensorNumInStation = 0;
  
  num_entries = fDigiArray->GetEntries();//get the num of entry in each event
 
  cout << "There are "<< num_entries<<" digis in event "<<fEventNum <<" ."<<endl;
  
  for(Int_t i = 0;i<fMaxNumberOfSensors;i++){
      Array_AT[i].clear();
  }
  
  for(num_loop=0;num_loop<num_entries;num_loop++)
  {
     fDigi = (CbmMvdDigi*)fDigiArray->At(num_loop);

     fStationNum = fDigi->GetStationNr();
     fPixel_X_InStation = fDigi->GetPixelX();
     fPixel_Y_InStation = fDigi->GetPixelY();
     fSensorNumInStation = (fPixel_X_InStation/1152+1)+(fPixel_Y_InStation/576)*5;
     if(fStationNum == fStationNr)
    {
      Array_AT[fSensorNumInStation].push_back(num_loop);
    }
  }
}
      
      
      
// for each row :get the coordinate of the hittd pixels,and store into the iLineArray[][] in order 
/** Attention :SensorNum shoud be in the range of 1-50 **/
void CbmMvdStringFinder::GetUsefulData(Int_t SensorNum)
{
  
  Int_t fPixel_X_InStation = 0;
  Int_t fPixel_Y_InStation = 0;
  Int_t fPixel_X_InSensor = 0;
  Int_t fPixel_Y_InSensor = 0;
  Int_t fIndex = 0;
  Int_t fNumOfLine = 0;
  Int_t fNumOfColumn = 0;
  
  fSensorID = SensorNum;
  fLineArray.clear();
  cout <<"There are " << Array_AT[ SensorNum ].size()<<" digis in sensor number " << SensorNum<<"."<<endl ;
  for(Int_t i=0;i<Array_AT[ SensorNum ].size();i++)
  {
      fIndex = Array_AT[ SensorNum ][ i ];
      fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
      fPixel_X_InStation = fDigi->GetPixelX();
      fPixel_Y_InStation = fDigi->GetPixelY();
      //translate the Inder X/Y into the x/y in sensor 
      fPixel_X_InSensor = fPixel_X_InStation%1152;
      fPixel_Y_InSensor = fPixel_Y_InStation%576;
      fNumOfLine = fLineArray.size();
      if(i == 0)
      {
	fLineArray.push_back(fCoordinate);
	fLineArray[0].push_back(fPixel_Y_InSensor);  
	fLineArray[0].push_back(fPixel_X_InSensor);
      }
      else
      {
	for(Int_t j=0;j<fNumOfLine;j++)
	{
	  if(fPixel_Y_InSensor == fLineArray[j][0])
	  {
	    fLineArray[j].push_back(fPixel_X_InSensor);
	    j = fNumOfLine;
	  }
	 else if( j== (fLineArray.size()-1))
	 {
	    fLineArray.push_back(fCoordinate);
	    fLineArray[j+1].push_back(fPixel_Y_InSensor);  
	    fLineArray[j+1].push_back(fPixel_X_InSensor);
	 }
       }
     }	
   }
   //order the Y and  X
   fNumOfLine = fLineArray.size();
   sort(&fLineArray[0],&fLineArray[fNumOfLine]);
   
   for(Int_t i=0;i<fNumOfLine;i++)
   {
    fNumOfColumn = fLineArray[i].size();
    sort(&fLineArray[i][1],&fLineArray[i][fNumOfColumn]);
  }

  
      
  
}

// store the num of digi into the fDigiLineArray[][];
// then separate them by Y and X coodinater,and order them.
/** Attention :SensorNum shoud be in the range of 1-50 **/
void CbmMvdStringFinder::GetStateDigi(Int_t sensorID)
{
 
  Int_t fPixel_X_position = 0;
  Int_t fPixel_Y_position = 0;
  Int_t fPixel_X2 = 0;
  Int_t fPixel_Y2 = 0;
  Int_t fIndex = 0;
  Int_t fIndex2 = 0;
  Int_t fNumOfLine = 0;
  
  fSensorID = sensorID;
  fDigiLineArray.clear();
  
  if(fLineArray.size() == 0)
    cout <<"Info:There is no any Digis in the  " <<fSensorID<<"th sensor of the "<< fStationID<<"th station"<<endl;
  else
  {
    for(Int_t i=0;i<Array_AT[ sensorID ].size();i++)
    {
	fIndex = Array_AT[ sensorID ][ i ];
	fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
	fPixel_X_position = fDigi->GetPixelX();
	fPixel_Y_position = fDigi->GetPixelY();

	fNumOfLine = fDigiLineArray.size();
	if(i == 0)
	{
	  fDigiLineArray.push_back(fDigiLine);
	  fDigiLineArray[0].push_back(fIndex);  
	}
	else
	{
	  for(Int_t j=0;j<fNumOfLine;j++)
	  {
            fIndex2 = fDigiLineArray[j][0];
	    fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex2);
            fPixel_Y2 = fDigi->GetPixelY();
            if(fPixel_Y_position == fPixel_Y2)
	    {
	      fDigiLineArray[j].push_back(fIndex);
	      j = fNumOfLine;
	    }
	    else if( j== (fNumOfLine-1))
	    {
	      fDigiLineArray.push_back(fDigiLine);
	      fDigiLineArray[j+1].push_back(fIndex);  
	  }
	  }
      }	
    }
   }
  

   //order the Y and  X
   fNumOfLine = fDigiLineArray.size();
   //sort the fIndex 
   Int_t exchange = fNumOfLine -1;
   Int_t bound = 0;
   Int_t Y1=0;
   Int_t Y2=0;
   vector< Int_t > fTemp;
   
   fTemp.clear();
   while(exchange)
   {
     bound = exchange;
     exchange = 0;
     for(Int_t i=0;i<bound;i++)
     {
	fIndex = fDigiLineArray[i][0];
	fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
	Y1 = fDigi->GetPixelY();
	fIndex = fDigiLineArray[i+1][0];
	fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
	Y2 = fDigi->GetPixelY();
	if(Y1>Y2)
	{
	  fTemp = fDigiLineArray[i];
	  fDigiLineArray[i] =  fDigiLineArray[i+1];
	  fDigiLineArray[i+1] = fTemp;
	  exchange = i;
	}
     }
    }
    
   //sort the X Index 
   Int_t X1=0;
   Int_t X2=0;
   Int_t fTemp2 = 0;
   for(Int_t i =0;i< fNumOfLine;i++)
   {
      exchange = fDigiLineArray[i].size()-1; 
      while(exchange)
      {
        bound = exchange;
        exchange = 0;
        for(Int_t j=0;j<bound;j++)
        {
	  fIndex = fDigiLineArray[i][j];
	  fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
	  X1 = fDigi->GetPixelX();
	  fIndex = fDigiLineArray[i][j+1];
	  fDigi = (CbmMvdDigi*)fDigiArray->At(fIndex);
	  X2 = fDigi->GetPixelX();
	  if(X1>X2)
	  {
	    fTemp2 = fDigiLineArray[i][j];
	    fDigiLineArray[i][j] =  fDigiLineArray[i][j+1];
	    fDigiLineArray[i][j+1] = fTemp2;
	    exchange = j;
	  }
	}
      }
     }
}
      
       
       
 

 
// Creat the dataframe of mimosa26 Based on the funtion of  GetUsefulData();
// store the data into a Int_t vector fFrameArray[],a char fMimoDataArray[570*2],
// store the Digi number of each state into the fStateMatchInformation for the statematch class
void CbmMvdStringFinder::CreatDataFrameMimosa26(){
  
  Int_t fLineNum = 0; 
  Int_t fDiff = 0;
  Int_t fStateNum =0;
  Int_t fStateCode = 0;
  Int_t fColAddr = 0;
  Int_t fRowAddr = 0;
 
  
  fDatalength0 = 0;
  fDatalength1 = 0;
  fStateNumInOneFrame = 0;
   
  fLineNum = fLineArray.size();
  
  fFrameArray.clear();
  fStateMatchInformation.clear();
  
  fFrameArray.push_back(fHeader0);
  fFrameArray.push_back(fHeader1);
  fFrameArray.push_back(fFrameCounter0);
  fFrameArray.push_back(fFrameConnter1);
 
  if(fLineArray.size() == 0)
    cout <<"Info:There is no any Digis in the  " <<fSensorID<<"th sensor of the "<< fStationID<<"th station"<<endl;
  else
  {
    for(Int_t i=0;i<fLineNum;i++)
    {
      if(fLineArray[i].size()<2)
	cout<<"ErrInfo:some wrong with data from digis"<<endl;
      else
      {
	fRowAddr = fLineArray[i][0];
	fColAddr = fLineArray[i][1];
	fStateNum = 0;
	fStateCode = 0;
	fTempArray.clear();
     
	for(Int_t j=1;j<fLineArray[i].size();j++)
	{
	  
	  if(j == fLineArray[i].size()-1)
	  {
	    fStateN = fStateCode*16384+fColAddr*8;
	    fTempArray.push_back(fStateN);
	    fStateNumInOneFrame++;
	    fStateNum++;
	    fDatalength0++;
	   
	    fStateMatchInformation.push_back(fOneState);
	    Int_t fIndex = fStateMatchInformation.size();
	    for(Int_t m=0;m<(fStateCode+1);m++)
	    {
	      fStateMatchInformation[fIndex-1].push_back(fDigiLineArray[i][j-fStateCode-1+m]);
	    }
	   }
	  else
	  {
	    fDiff = fLineArray[i][j+1]-fLineArray[i][j];
	    if(fDiff > 1 ||fStateCode == 3 )// save one state into a temp vector
	    {
	      fStateN = fStateCode*16384+fColAddr*8;
	      fTempArray.push_back(fStateN);
	      fStateNum++;
	      fStateNumInOneFrame++;
	     
	      fDatalength0++;
	      fStateMatchInformation.push_back(fOneState);
	      Int_t fIndex = fStateMatchInformation.size();
	      for(Int_t m=0;m<(fStateCode+1);m++)
	      {
		fStateMatchInformation[fIndex-1].push_back(fDigiLineArray[i][j-fStateCode-1+m]);
	      }
	    //reset for a new state
	      fColAddr = fLineArray[i][j+1];
	      fStateCode = 0;
	    }
	    else if(fDiff==1)
	    {
	      fStateCode++;
	    }
	  }
	}
	 
	}
	if(fStateNum > 9)
	{
	cout<<"there are more than 9 state in one row,the num is " <<fStateNum<<endl;
	fStateline =1 + fStateNum*4096 + fRowAddr*2;
      }
	else
	  fStateline = fStateNum*4096 + fRowAddr*2;
    
/** store the state data into array**/
	fFrameArray.push_back(fStateline);
	for(Int_t m=0;m<fTempArray.size();m++)
	{
	  fFrameArray.push_back(fTempArray[m]);
	}
	fDatalength0++;
	if(fDatalength1==65535 && fDatalength0==65535)
	{
	  fDatalength0 = 0;
	  fDatalength1 = 0;
	}
	else
	if(fDatalength0==65535)
	{
	  fDatalength0 = 0;
	  fDatalength1 = fDatalength1 + 1;
	}
    }
    
    fFrameArray.insert(fFrameArray.begin()+4,fDatalength0);
    fFrameArray.insert(fFrameArray.begin()+5,fDatalength1);

    fFrameArray.push_back(fTrailer0);
    fFrameArray.push_back(fTrailer1);
    
    /**translate 16bits into 8 bit(char)**/
    if(fFrameArray.size() > fByteNumberOfData/2)
    {
      cout << "Error: the Length of Data is overflow....";
    }
    else
    {
      for(Int_t i = 0;i<fFrameArray.size();i++)
      {
	fMimoDataArray[2*i] = (fFrameArray[i]% 256);
	fMimoDataArray[2*i+1] = (fFrameArray[i] / 256);
      }
      for(Int_t j=2*fFrameArray.size();j<fByteNumberOfData;j++)
	fMimoDataArray[j] = 0;
    }
  }

}


  
/** Exec function **/
void CbmMvdStringFinder::Exec(Option_t* opt){
  
  
  fMimoData->Clear();
  fMimoDataStateMatch->Clear();
  fEventNum++;
  Int_t fNum = 0;
  Int_t header = 0;
  
  ReadOfFDigi(1);//get all the Digi nymber for of each sensor of 1 station
  GetUsefulData(27);//get the real data(x,y) of one sensor by row 
  GetStateDigi(27);//get the digi Num of one sensor by row
  CreatDataFrameMimosa26();//creat the standard Mimosa data frame,store into a fFrameArray[570]*16bits  and array[570*2]*8bits
 
  fROCFrame = 1;
  fTimeStamp = 2;
  fSensorOffset = 3;
  fTemp = 4;
  fROCAddress = 5; 
   
  cout << "Writing MimoData into String.root of the "<< fEventNum <<" Event" <<endl;
  fNum = fMimoData->GetEntriesFast(); 
  new ((*fMimoData)[fNum]) CbmMvdMimoData(fROCFrame,fTimeStamp,fSensorOffset,fTemp,fROCAddress,fMimoDataArray,fStateNumInOneFrame);
 
  cout << "Writing MimoDataStateMatch into String.root of the "<< fEventNum <<" Event" <<endl;
  fNum = fMimoDataStateMatch->GetEntriesFast();
  new ((*fMimoDataStateMatch)[fNum]) CbmMvdMimoStateMatch(fROCFrame,fTimeStamp,fSensorOffset,fTemp,fROCAddress,fStateMatchInformation);

}
  
 


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



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

ClassImp(CbmMvdStringFinder)