/////////////////////////////////////////////////////////////
// DchDetector
//
// Class for DchDetector
//
/////////////////////////////////////////////////////////////

#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 "DchGeo.h"
#include "DchDetector.h"	
#include "DchPoint.h"
#include "CbmGeoG3Builder.h"
#include "CbmRuntimeDb.h"
#include "DchGeoPar.h"
#include "TObjArray.h"
#include "CbmRun.h"

// -----   Default constructor   -------------------------------------------
DchDetector::DchDetector() {
  fDchPointCollection        = new TClonesArray("DchPoint");
  fPosIndex   = 0;
  volDetector = 0;
}
// -------------------------------------------------------------------------

// -----   Standard constructor   ------------------------------------------
DchDetector::DchDetector(const char* name, Bool_t active)
  : CbmDetector(name, active) {
    fDchPointCollection        = new TClonesArray("DchPoint");
    fPosIndex   = 0;
    volDetector = 0;
    fevent=-1;
}
// -------------------------------------------------------------------------

// -----   Destructor   ----------------------------------------------------
DchDetector::~DchDetector() {
  if (fDchPointCollection) {
    fDchPointCollection->Delete();
    delete fDchPointCollection;
  }
  
}
// -------------------------------------------------------------------------

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


  Int_t copyNo;  
  gMC->CurrentVolID(copyNo);
  TString nam = gMC->CurrentVolName(); //string with the correct name
  TString curnam = nam;
  curnam.Remove(0,curnam.Length()-2);
  fModuleID = curnam.Atoi();
  std::cout<<"III DchDetector::ProcessHits() : copyNo = "<<copyNo<<" "<<curnam<<std::endl;
  
  fVolumeID = copyNo; // copy Number
  fcurrnam=nam;
  nam = nam + "_";
  nam +=copyNo;
  fcurrnam2 = nam;
  //-------------------------------------------

  // if entering
  if ( gMC->IsTrackEntering() ) {
    fELoss  = 0.;
    fTime   = gMC->TrackTime() * 1.0e09; // time
    fLength = gMC->TrackLength();
    gMC->TrackPosition(fPosIn); // cm
    gMC->TrackMomentum(fMomIn); // GeV
  }
   
  // Sum energy loss for all steps in the active volume
  fELoss += gMC->Edep();

  // Set additional parameters at exit of active volume. Create DchPoint.
  if ( gMC->IsTrackExiting()    ||
       gMC->IsTrackStop()       ||
       gMC->IsTrackDisappeared()   ) {
    gMC->TrackPosition(fPosOut); // cm
    gMC->TrackMomentum(fMomOut); // GeV
    //    if (fELoss == 0. ) return kFALSE;
  }

  AddHit(fTrackID, fVolumeID, fModuleID,
	 TVector3(fPosIn.X(),   fPosIn.Y(),   fPosIn.Z()),
	 TVector3(fPosOut.X(),  fPosOut.Y(),  fPosOut.Z()),
	 TVector3(fMomIn.Px(),  fMomIn.Py(),  fMomIn.Pz()),
	 TVector3(fMomOut.Px(), fMomOut.Py(), fMomOut.Pz()),
 	 fTime, fLength, fELoss, nam,fevent);


  // TO BE SET AS DEBUG 
  // cout << "PARAMETERS ----------" << endl;
  // cout << "trk " << fTrackID << " vol " << fVolumeID <<  fModuleID <<endl;
  // cout << " pos in " << fPosIn.X() << " " << fPosIn.Y() << " " << fPosIn.Z() << endl;
  // cout << " pos out " << fPosOut.X() << " " << fPosOut.Y() << " " <<  fPosOut.Z() << endl;
  // cout << " mom in " << fMomIn.X() << " " << fMomIn.Y() << " " << fMomIn.Z() << endl;
  // cout << " mom out " << fMomOut.X() << " " << fMomOut.Y() << " " <<  fMomOut.Z() << endl;
  // cout << " time " << fTime << " length " << fLength << " Eloss " << fELoss << endl;
  // cout << " charge " << fcharge << " mass " << fmass << " pre/pos " << fpreflag << " " << fpostflag << endl;
  // cout << " ----------" << endl;

 ResetParameters();


 return kTRUE;
  
}
// ----------------------------------------------------------------------------

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

// -----   Public method Register   -------------------------------------------
void DchDetector::Register() {
  CbmRootManager::Instance()->Register("DchPoint","Dch", fDchPointCollection, kTRUE);
}
// ----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  TList* volList = dchGeo->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();
  DchGeoPar* par=(DchGeoPar*)(rtdb->getContainer("DchGeoPar"));
  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 DchPoint for hit description
DchPoint* DchDetector::AddHit(Int_t trackID, Int_t detID,  Int_t moduleID, 
			    TVector3 posIn, TVector3 posOut, 
			    TVector3 momIn, TVector3 momOut, 
			    Double_t time, Double_t length, Double_t eLoss, 
			    TString nam,Int_t evt) {
  TClonesArray& clref = *fDchPointCollection;
  Int_t size = clref.GetEntriesFast();
  if (fVerboseLevel>1) 
    cout << "-I- DchDetector: Adding Point at IN (" << posIn.X() << ", " << posIn.Y() 
	 << ", " << posIn.Z() << ") cm, OUT ("<<  posOut.X()<< ", " << posOut.Y()
	 <<" "<<posOut.Z()<<") cm, plane " << detID <<", chamber "<<moduleID<<", track "
	 << trackID <<" event "<<evt<< ", energy loss " << eLoss*1e06 << " keV" << endl;
  return new(clref[size]) DchPoint(trackID, detID, moduleID, posIn, posOut,
				      momIn, momOut, time, length, eLoss);
}
// ----------------------------------------------------------------------------

ClassImp(DchDetector)