// -------------------------------------------------------------------------
// -----                     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) {
 
  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";
    
      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
	  {
	   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
	  {
	   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(){ 

  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  
  for(Int_t j = 0; j < nSensors; j++)
    {
    sensor=(CbmMvdSensor*)fSensorArray->At(j);
    cout << "Init Sensor " << sensor->GetName() << endl;
    sensor=(CbmMvdSensor*)fSensorArray->At(j);
    sensor->Init();
    }
  
 
}

//-----------------------------------------------------------------------
void CbmMvdDetector::SendInput(TClonesArray* input){
  
  Int_t nSensors=fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    //cout << "I------ Send Input to " << sensor->GetName() << endl;
    sensor->SendInput(input);
    //cout << "I------ finished Input at "<< sensor->GetName() <<endl<< endl;
  };
}
//-----------------------------------------------------------------------

void CbmMvdDetector::ExecChain(){

  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){

  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(){
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  TClonesArray* currentEvent = new TClonesArray("CbmMvdHit",1000);
  TClonesArray* output = new TClonesArray("CbmMvdPoint",1000);
  for(Int_t i=0; i<nSensors; i++){
    sensor=(CbmMvdSensor*)fSensorArray->At(i);
    output = sensor->GetOutputArray(0);
    
    
    if (output > 0)
    {
      Int_t nHits = output->GetEntriesFast();
      output->Print();
      for(Int_t j=0; j<nHits; j++)
          {
           cout << "Writing new Hit in currentEvent" << endl;
           new((*currentEvent)[currentEvent->GetEntriesFast()]) CbmMvdHit(*((CbmMvdHit*)output->At(j)));
           currentEvent->Print();
          }
    }
  }

   return(output); 
}   
    
 
 
ClassImp(CbmMvdDetector)