/////////////////////////////////////////////////////////////
// FscDetector
//
// Class for FscDetector
//
/////////////////////////////////////////////////////////////

#include "iostream.h"

#include "TClonesArray.h"
#include "TGeoMCGeometry.h"
#include "TGeoManager.h"
#include "TLorentzVector.h"
#include "TParticle.h"
#include "TVirtualMC.h"

#include "CbmGeoInterface.h"
#include "CbmGeoLoader.h"
#include "CbmGeoNode.h"
#include "CbmGeoRootBuilder.h"
#include "CbmStack.h"
#include "CbmRootManager.h"
#include "CbmVolume.h"
#include "FscGeo.h"
#include "FscDetector.h"	
#include "FscPoint.h"
#include "CbmGeoG3Builder.h"
#include "CbmRuntimeDb.h"
#include "FscGeoPar.h"
#include "TObjArray.h"
#include "CbmRun.h"

// -----   Default constructor   -------------------------------------------
FscDetector::FscDetector() {
  fFscPointCollection        = new TClonesArray("FscPoint");
  fPosIndex   = 0;
  fDetectorID = 0;
}
// -------------------------------------------------------------------------

// -----   Standard constructor   ------------------------------------------
FscDetector::FscDetector(const char* name, Bool_t active)
  : CbmDetector(name, active) {
    fFscPointCollection        = new TClonesArray("FscPoint");
    fPosIndex   = 0;
    fDetectorID = 0;
    fEventID=-1;
    SetVerboseLevel(2);
}
// -------------------------------------------------------------------------

// -----   Destructor   ----------------------------------------------------
FscDetector::~FscDetector() {
  if (fFscPointCollection) {
    fFscPointCollection->Delete();
    delete fFscPointCollection;
  }
  
}
// -------------------------------------------------------------------------

// -----   Public method ProcessHits  --------------------------------------
Bool_t FscDetector::ProcessHits(CbmVolume* vol) {
  fTrackID  = gMC->GetStack()->GetCurrentTrackNumber(); // trk ID
  fEventID = gMC->CurrentEvent();

  Int_t copyNo = -1, lay = -1;
  Int_t module = 5,row = -1, crys = -1; 

  gMC->CurrentVolID(lay);

  //std::cout<<"III FscDetector::ProcessHits() : layer = "<<lay<<
  //  ", volume name = "<<gMC->CurrentVolName()<<std::endl;
  
  Int_t crystalCopyNo=-1, crystalID=-1;
  TString crystalName="";
  crystalID=gMC->CurrentVolOffID(1, crystalCopyNo);
  crystalName = gMC->CurrentVolOffName(1);
  //std::cout<<"HHHH  "<<crystalName<<"\t"<<crystalCopyNo<<std::endl;

  row = crystalCopyNo%100;
  crys = crystalCopyNo/100;
  copyNo = crystalCopyNo;

  //std::cout<<"Row = "<<row<<" Crystal = "<<crys<<" CopyNo = "<<copyNo<<std::endl;
  
  fVolumeID = module*100000000 + row*1000000 + copyNo*10000 + crys; 
  //-------------------------------------------

  fELoss = gMC->Edep();
  fLength =  gMC->TrackLength();
  fTime =  gMC->TrackTime();
  gMC->TrackPosition(fPos); // cm
  gMC->TrackMomentum(fMom); // GeV
  

  // Set additional parameters at exit of active volume. Create FscPoint.
  
  if(fELoss>0.)
    AddHit(fTrackID, fVolumeID, fEventID,
	   TVector3(fPos.X(),   fPos.Y(),   fPos.Z()),
	   TVector3(fMom.Px(),  fMom.Py(),  fMom.Pz()),
	   fTime, fLength, fELoss, module, row, crys, copyNo, lay);
  
  ResetParameters();
  
  
  return kTRUE;
  
}
// ----------------------------------------------------------------------------

// -----   Public method EndOfEvent   -----------------------------------------
void FscDetector::EndOfEvent() {
  if (fVerboseLevel)  Print();
  Reset();
}
// ----------------------------------------------------------------------------

// -----   Public method Register   -------------------------------------------
void FscDetector::Register() {
  CbmRootManager::Instance()->Register("FscPoint","Fsc", fFscPointCollection, kTRUE);
}
// ----------------------------------------------------------------------------

// -----   Public method GetCollection   --------------------------------------
TClonesArray* FscDetector::GetCollection(Int_t iColl) const {
   if (iColl == 0) return fFscPointCollection;

  return NULL;
}
// ----------------------------------------------------------------------------

// -----   Public method Print   ----------------------------------------------
void FscDetector::Print() const {
    Int_t nHits = fFscPointCollection->GetEntriesFast();
    cout << "-I- FscDetector: " << nHits << " points registered in this event."
 	<< endl;

    if (fVerboseLevel>1)
      for (Int_t i=0; i<nHits; i++) (*fFscPointCollection)[i]->Print();
}
// ----------------------------------------------------------------------------

// -----   Public method Reset   ----------------------------------------------
void FscDetector::Reset() {
  fFscPointCollection->Clear();  
  fPosIndex = 0;
}
// ----------------------------------------------------------------------------

// -----   Public method CopyClones   -----------------------------------------
// void FscDetector::CopyClones(TClonesArray* cl1, TClonesArray* cl2, Int_t offset ) {
//   Int_t nEntries = cl1->GetEntriesFast();
//   cout << "-I- FscDetector: " << nEntries << " entries to add." << endl;
//   TClonesArray& clref = *cl2;
//   FscPoint* oldpoint = NULL;
//   for (Int_t i=0; i<nEntries; i++) {
//     oldpoint = (FscPoint*) cl1->At(i);
//     Int_t index = oldpoint->GetTrackID() + offset;
//     oldpoint->SetTrackID(index);
//     new (clref[fPosIndex]) FscPoint(*oldpoint);
//     fPosIndex++;
//   }
//   cout << " -I- FscDetector: " << cl2->GetEntriesFast() << " merged entries."
//        << endl;
// }
// ----------------------------------------------------------------------------

// -----   Public method ConstructGeometry   ----------------------------------
void FscDetector::ConstructGeometry() {

  std::cout<<" --- Building FSC Geometry ---"<<std::endl;

  CbmGeoLoader*    geoLoad = CbmGeoLoader::Instance();
  CbmGeoInterface* geoIFace = geoLoad->getGeoInterface();
  FscGeo*      fscGeo = new FscGeo();
  fscGeo->setGeomFile(GetGeometryFileName());
  std::cout<<"Geometry filename = "<<GetGeometryFileName()<<std::endl;
  geoIFace->addGeoModule(fscGeo);
  
  Bool_t rc = geoIFace->readSet(fscGeo);
  if (rc) fscGeo->create(geoLoad->getGeoBuilder());
  else std::cerr<<"FscDetector:: geometry could not be read!"<<std::endl;

  TList* volList = fscGeo->getListOfVolumes();
  std::cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<std::endl;
  std::cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<std::endl;
  std::cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<std::endl;
  std::cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<std::endl;
  std::cout<<"volList contains "<<volList->GetEntries()<<" volumes"<<std::endl;

  // store geo parameter
  CbmRun *fRun = CbmRun::Instance();
  CbmRuntimeDb *rtdb= CbmRun::Instance()->GetRuntimeDb();
  FscGeoPar* par=(FscGeoPar*)(rtdb->getContainer("FscGeoPar"));
  TObjArray *fSensNodes = par->GetGeoSensitiveNodes();
  TObjArray *fPassNodes = par->GetGeoPassiveNodes();

  TListIter iter(volList);
  CbmGeoNode* node   = NULL;
  CbmGeoVolume *aVol=NULL;

  while( (node = (CbmGeoNode*)iter.Next()) ) {
    std::cout<<"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&  "<<    node->GetName()<<std::endl;
    aVol = dynamic_cast<CbmGeoVolume*> ( node );
    if ( node->isSensitive()  ) {
      fSensNodes->AddLast( aVol );
    }else{
      fPassNodes->AddLast( aVol );
    }
  }
  par->setChanged();
  par->setInputVersion(fRun->GetRunId(),1);

  // set active/inactive
  ProcessNodes( volList );
  std::cout<<"koniec"<<std::endl;

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

// -----   Private method AddHit   --------------------------------------------
// see FscPoint for hit description
FscPoint* FscDetector::AddHit(Int_t trackID, Int_t detID, Int_t evtID,
			      TVector3 pos, TVector3 mom,  
			      Double_t time, Double_t length, Double_t eLoss, 
			      Short_t module, Short_t row, Short_t crys, 
			      Short_t copyNo, Int_t layer) {
  TClonesArray& clref = *fFscPointCollection;
  Int_t size = clref.GetEntriesFast();
  if (fVerboseLevel>1) 
    cout << "-I- FscDetector: Adding Point at (" << pos.X() << ", " << pos.Y() 
	 << ", " << pos.Z() << ") cm,  detector " << detID <<", track "
	 << trackID <<" event "<<evtID<< ", energy loss " << eLoss*1e06 << " keV" << endl;
  return new(clref[size]) FscPoint(trackID, detID, evtID, pos, mom, time, 
				   length, eLoss,module, row, crys, copyNo, layer);
}
// ----------------------------------------------------------------------------

ClassImp(FscDetector)