// -------------------------------------------------------------------------
// -----                     CbmMvdDetector source file                  -----
// -----                  Created 31/01/11  by M. Deveaux              -----
// -------------------------------------------------------------------------

#include "CbmMvdDetector.h"

#include <iostream>


using std::cout;
using std::endl;

//_____________________________________________________________________________
CbmMvdDetector* CbmMvdDetector::fInstance= 0;
//_____________________________________________________________________________
CbmMvdDetector* CbmMvdDetector::Instance()
{
  return fInstance;
}

// -----   Default constructor   -------------------------------------------
CbmMvdDetector::CbmMvdDetector() {

  Fatal (GetName(), " - Do not use standard constructor");

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



// -----   Standard constructor   ------------------------------------------
CbmMvdDetector::CbmMvdDetector(const char* name)
{
 
  if(fInstance) {Fatal(GetName(), " - Error, singleton does already exist.");}
  else {fInstance=this;};
  fSensorArray=new TClonesArray("CbmMvdSensor", 10);
  fPluginArray=new TObjArray(2);
  fSensorArrayFilled=kFALSE;
	
}
// -------------------------------------------------------------------------



// -----   Destructor   ----------------------------------------------------
CbmMvdDetector::~CbmMvdDetector() {
  
}
// -------Setters -----------------------------------------------------

void CbmMvdDetector::AddSensor(TString clearName, TString fullName, TString nodeName, 
			       CbmMvdSensorDataSheet* sensorData, Int_t stationNr, Int_t volumeId, Double_t sensorStartTime) {
 
  /**
   * 
   * new sensor is registered in sensor array 
   * 
   * **/
  
  if (fSensorArrayFilled) {Fatal (GetName(), " - Error, must add all sensors before adding plugins.");}
  
  
  Int_t nSensors=fSensorArray->GetEntriesFast();
 
  new ((*fSensorArray)[nSensors]) CbmMvdSensor(clearName, sensorData, fullName, nodeName,stationNr,volumeId,sensorStartTime);
  //CbmMvdSensor(const char* name, CbmMvdSensorDataSheet* dataSheet, TString volName,
  //TString nodeName, Int_t stationNr, Int_t volumeId, Double_t sensorStartTime);
 
  CbmMvdSensor* sensor = (CbmMvdSensor*)fSensorArray->At(nSensors);
  sensor->SetDataSheet(sensorData);
  //cout << endl << "new sensor to detector added" << endl;
} 
 
// ----------------------------------------------------------------------

void CbmMvdDetector::AddPlugin(CbmMvdSensorPlugin* plugin) {
  
/**
 * if there is a new buffer or task typ you have to insert it here 
 * or you can't use it.
 */

  CbmMvdSensor* sensor;
  Int_t nSensors=fSensorArray->GetEntriesFast();
  
  for (Int_t i=0;i<nSensors; i++){
   
    
    if(plugin->GetPluginType() == task)
      {
      TString digitizername = "CbmMvdSensorDigitizerTask";
      TString findername = "CbmMvdSensorFindHitTask";
      if (plugin->ClassName() == digitizername)
	  {
	  CbmMvdSensorDigitizerTask* digiTask = new CbmMvdSensorDigitizerTask;
	  sensor=(CbmMvdSensor*)fSensorArray->At(i);
	  sensor->AddPlugin(digiTask);
	  cout <<  "Adding Task CbmMvdSensorDigitizerTask at Sensor " << sensor->GetName() << endl;
	  }
      else if (plugin->ClassName() == findername)
	  {
	  CbmMvdSensorFindHitTask* findTask = new CbmMvdSensorFindHitTask;
	  sensor=(CbmMvdSensor*)fSensorArray->At(i);
	  sensor->AddPlugin(findTask);
	  cout <<  "Adding Task CbmMvdSensorFindHitTask at Sensor " << sensor->GetName() << endl;
	  }
      
      
      else 
	  {
	   cout << endl << "task not included yet, adding standart task." << endl;
	   CbmMvdSensorTask* task = new CbmMvdSensorTask;
	   sensor=(CbmMvdSensor*)fSensorArray->At(i);
	   sensor->AddPlugin(task);
	  }
      //data parallelizm requires that each sensor get its own task object
    
    }
    
    else if( plugin->GetPluginType() == buffer)
    {
     // cout << endl << "Type is Buffer" << endl;
     // cout << endl <<  plugin->ClassName() << endl;
      TString framename = "CbmMvdSensorFrameBuffer";
      TString trackingname = "CbmMvdSensorTrackingBuffer";
     
      if ( plugin->ClassName() == framename)
	  {
	  CbmMvdSensorFrameBuffer* frameBuffer = new CbmMvdSensorFrameBuffer;
	  sensor=(CbmMvdSensor*)fSensorArray->At(i);
	  sensor->AddPlugin(frameBuffer);
          cout << "Adding Buffer CbmMvdSensorFrameBuffer at Sensor " << sensor->GetName() << endl;
	  }
      else if ( plugin->ClassName() == trackingname)
	  {
	  CbmMvdSensorTrackingBuffer* trackingBuffer = new CbmMvdSensorTrackingBuffer;
	  sensor=(CbmMvdSensor*)fSensorArray->At(i);
	  sensor->AddPlugin(trackingBuffer);
          cout << "Adding Buffer CbmMvdSensorTrackingBuffer at Sensor " << sensor->GetName() << endl;
	  }
	else  
	  {
	   cout << endl << "buffer not included yet, adding standart buffer." << endl;
	   CbmMvdSensorBuffer* buffer = new CbmMvdSensorBuffer;
	   sensor=(CbmMvdSensor*)fSensorArray->At(i);
	   sensor->AddPlugin(buffer);
	  }
      //data parallelizm requires that each sensor get its own buffer object
    
    }
    else {cout << "Invalide" << endl;}
  };
  
};

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

void CbmMvdDetector::Init(){ 

  /**
   * 
   * Initialisation method
   * 
   * **/
  
  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  foutput = new TClonesArray("CbmMvdPoint",1000);
  fcurrentEvent = new TClonesArray("CbmMvdPoint",1000);
  foutputDigis = new TClonesArray("CbmMvdDigi",1000);
  foutputHits = new TClonesArray("CbmMvdHit",1000);
  for(Int_t j = 0; j < nSensors; j++)
    {
    sensor=(CbmMvdSensor*)fSensorArray->At(j);
    cout << "Init Sensor " << sensor->GetName() << endl;
    sensor->Init();
    }
  
 
}

//-----------------------------------------------------------------------
void CbmMvdDetector::SendInput(TClonesArray* input){

  /**
   * 
   * Sending event to sensors, 
   * each sensor gets only his own points
   * 
   * TODO: find faster way to re-sort points to sensors
   * 
   * **/
  

  CbmMvdPoint* point;
  Int_t nEntries = input->GetEntriesFast();
  Int_t i=0;
  Int_t k=0;
  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  Bool_t bWritten = false;
  
   while ( nEntries > i )   
	{
	point= (CbmMvdPoint*) input->At(i);
	while( k < nSensors )
	   {
	  
// 	   cout << endl << "k =  " << k << endl;
	   sensor=(CbmMvdSensor*)fSensorArray->At(k);
	   if (point->GetDetectorID()==sensor->GetDetectorID())
	     {
              sensor->SendInput(point);
	      //input->RemoveAt(0);
	      //input->Compress();
	      nEntries = input->GetEntriesFast();
	      bWritten = true;
	      k = 0;
// 	      cout << endl << "point registert" << endl;
// 	      cout << endl << "new nEntries " << nEntries << endl;
	      
             }
           if (bWritten)
	   {
	    bWritten = false;
// 	    cout << endl << "Point registered end Sensorloop " << endl;
	    break;
	   }
	    k++;
	   }
	   i++;
// 	   cout << endl << "i =  " << i << endl;
        };
   
   
}
//-----------------------------------------------------------------------

void CbmMvdDetector::ExecChain(){
  
/**
   * 
   * method to execute plugin chain on sensors
   * 
   * **/
  
  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    //cout << "I------ Send Chain to " << sensor->GetName() << endl;
    sensor->ExecChain();
    //cout << "I------ finished Chain at "<< sensor->GetName() <<endl<< endl;
  };
  
 
}

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

void CbmMvdDetector::Exec(UInt_t nLevel){

  /**
   * 
   * execute spezific plugin on all sensors
   * 
   * **/
  
  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    sensor->Exec(nLevel);
  }
}

//-----------------------------------------------------------------------
    
TClonesArray* CbmMvdDetector::GetCurrentEvent(){
  
  /**
   * Method used for debugging, Plugins have to hold there output until next call
   */
  
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
   // foutput = sensor->GetOutputArray(0);
    fcurrentEvent->AbsorbObjects(sensor->GetOutputArray(0));
       
  }

return(fcurrentEvent);
}   
    
 
//-----------------------------------------------------------------------
    
TClonesArray* CbmMvdDetector::GetOutputHits(){
  
   /**
   * method used to write hits to hd
   */
   
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    foutputHits->AbsorbObjects(sensor->GetOutputBuffer());
  }

return(foutputHits);
} 
//-----------------------------------------------------------------------

TClonesArray* CbmMvdDetector::GetOutputDigis(){
  
   /**
   * method used to write digis to hd
   */
   
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    fDigiPlugin = sensor->GetDigiPlugin();
    foutputDigis->AbsorbObjects(sensor->GetOutputArray(fDigiPlugin));
  }

return(foutputDigis);
} 

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

TClonesArray* CbmMvdDetector::GetOutputArray(Int_t nPlugin){
  
   /**
   * method used to write processed events to hd
   */
   
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    foutputDigis->AbsorbObjects(sensor->GetOutputArray(nPlugin));
  }

return(foutputDigis);
} 
    
ClassImp(CbmMvdDetector)