#include <iostream>
#include <string>
#include <sstream>

#include "MvdDetector.h"

#include "TClonesArray.h"
#include "TLorentzVector.h"
#include "TParticle.h"
#include "TVirtualMC.h"
#include "TObjArray.h"
#include "TList.h"
#include "TKey.h"
#include "TGeoManager.h"

#include "CbmGeoInterface.h"
#include "CbmGeoLoader.h"
#include "CbmGeoNode.h"
#include "CbmGeoRootBuilder.h"
#include "CbmRootManager.h"
#include "CbmRuntimeDb.h"
#include "CbmRun.h"
#include "CbmGeoMedia.h"
#include "CbmGeoVolume.h"
#include "CbmRunSim.h"

#include "MvdGeoMappingPar.h"
#include "MvdDetIdPair.h"
#include "MvdPoint.h"
#include "MvdGeo.h"
#include "MvdGeoPar.h"


class CbmVolume;

// -----   Default constructor   -------------------------------------------
MvdDetector::MvdDetector() {
  fMvdCollection = new TClonesArray("MvdPoint");
  fPosIndex = 0;
  fVerboseLevel = 1;
  fListOfSensitives.push_back("StripSensor");
  fListOfSensitives.push_back("SensorActiveArea");
  if (fVerboseLevel>0) {
    std::cout<<"-I- MvdDetector: fListOfSensitives contains:";
    for(int k=0;k<fListOfSensitives.size();k++)
      std::cout<<"\n\t"<<fListOfSensitives[k];
    std::cout<<std::endl;
  }
}
// -------------------------------------------------------------------------



// -----   Standard constructor   ------------------------------------------
MvdDetector::MvdDetector(const char* name, Bool_t active)
  : CbmDetector(name, active) {
  fMvdCollection = new TClonesArray("MvdPoint");
  fPosIndex = 0;
  fVerboseLevel = 1;
  fListOfSensitives.push_back("StripSensor");
  fListOfSensitives.push_back("SensorActiveArea");
  if (fVerboseLevel>0) {
    std::cout<<"- I - MvdDetector: fListOfSensitives contains:";
    for(int k=0;k<fListOfSensitives.size();k++)
      std::cout<<"\n\t"<<fListOfSensitives[k];
    std::cout<<std::endl;
  }
}
// -------------------------------------------------------------------------




// -----   Destructor   ----------------------------------------------------
MvdDetector::~MvdDetector()
{
  if (fMvdCollection) 
    {
      fMvdCollection->Delete(); 
      delete fMvdCollection;
    }
}
// -------------------------------------------------------------------------
void MvdDetector::Initialize()
{
  CbmDetector::Initialize();
}


// -----   Public method ProcessHits  --------------------------------------
Bool_t  MvdDetector::ProcessHits(CbmVolume* vol)
{


  if ( gMC->IsTrackEntering() ) 
    {
	  // Set parameters at entrance of volume. Reset ELoss.
	  fELoss  = 0.;
	  fTime   = gMC->TrackTime() * 1.0e09;
	  fLength = gMC->TrackLength();
	  gMC->TrackPosition(fPosIn);
	  gMC->TrackMomentum(fMomIn);
    }

  // Sum energy loss for all steps in the active volume
  fELoss += gMC->Edep();


  // Create MvdPoint at exit of active volume

  if ( gMC->IsTrackExiting()    ||
       gMC->IsTrackStop()       ||
       gMC->IsTrackDisappeared()   ) {
       
      fTrackID  = gMC->GetStack()->GetCurrentTrackNumber();

       if (fDetIDMap[gGeoManager->GetPath()] == 0){
      	fDetIDMap[gGeoManager->GetPath()] = fDetIDMap.size()+1;
       }
      fVolumeID = fDetIDMap[gGeoManager->GetPath()];
      if (fVerboseLevel > 1){
      	std::cout << "*******  Info from gMC *************" << std::endl;
      	std::cout << "Hit in " << gGeoManager->GetPath() << " with MCiD: " << vol->getMCid() << " volumeID: " << fVolumeID << std::endl;
        std::cout<<"Name: "<<vol->GetName()<<std::endl;
      	std::cout << "PosIn: " << fPosIn.X() << " " << fPosIn.Y() << " " << fPosIn.Z() << " " << fELoss << std::endl;
      }
      //fVolumeID = gGeoManager->GetCurrentNodeId();
      gMC->TrackPosition(fPosOut);
      gMC->TrackMomentum(fMomOut);

     if (fELoss == 0.) return kFALSE;
      
      AddHit(fTrackID, fVolumeID, gGeoManager->GetPath(),
	     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);

      // Increment number of Mvd points for TParticle
      Int_t 
	points = gMC->GetStack()->GetCurrentTrack()->GetMother(1);

      Int_t 
	nMvdPoints = (points & (15<<24)) >> 24;

      nMvdPoints ++;

      if (nMvdPoints > 15) 
	nMvdPoints = 15;

      points = ( points & ( ~ (15<<24) ) ) | (nMvdPoints << 24);

      gMC->GetStack()->GetCurrentTrack()->SetMother(1,points);
      
      ResetParameters();
    }

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



// -----   Public method EndOfEvent   --------------------------------------
void MvdDetector::EndOfEvent()
{
  if (fVerboseLevel) 
    Print();

  fMvdCollection->Clear();
  fPosIndex = 0;
}
// -------------------------------------------------------------------------

void MvdDetector::FinishRun()
{
  CbmRun *fRun = CbmRun::Instance();
  CbmRuntimeDb *rtdb= CbmRun::Instance()->GetRuntimeDb();

  MvdGeoMappingPar *par= (MvdGeoMappingPar*)(rtdb->getContainer("MvdGeoMappingPar"));

  TObjArray* detIdPairs = par->getPairs();

  for (std::map<TString, int>::const_iterator it = fDetIDMap.begin();
	it!=fDetIDMap.end(); ++it){
           detIdPairs->AddLast( new MvdDetIdPair(it->second, it->first) );
  }

  par->setChanged();
  par->setInputVersion(fRun->GetRunId(),1);
}

// -----   Public method Register   ----------------------------------------
void MvdDetector::Register()
{
  CbmRootManager::Instance()->Register("MVDPoint", "Mvd", fMvdCollection, kTRUE);
}
// -------------------------------------------------------------------------



// -----   Public method GetCollection   -----------------------------------
TClonesArray* MvdDetector::GetCollection(Int_t iColl) const 
{
  if (iColl == 0) 
    return fMvdCollection;
  else 
    return NULL;
}
// -------------------------------------------------------------------------



// -----   Public method Print   -------------------------------------------
void MvdDetector::Print() const
{
  Int_t 
    nHits = fMvdCollection->GetEntriesFast();

  std::cout << "-I- MvdDetector: " << nHits << " points registered in this event."  << std::endl;

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



// -----   Public method Reset   -------------------------------------------
void MvdDetector::Reset()
{
  fMvdCollection->Clear();
  ResetParameters();
}
// -------------------------------------------------------------------------



// -----   Public method CopyClones   --------------------------------------
void MvdDetector::CopyClones(TClonesArray* cl1, TClonesArray* cl2, Int_t offset)
{
  Int_t 
    nEntries = cl1->GetEntriesFast();

  std::cout << "-I- MvdDetector: " << nEntries << " entries to add." << std::endl;

  TClonesArray& clref = *cl2;

  MvdPoint
    *oldpoint = NULL;
   for (Int_t i=0; i<nEntries; i++) 
     {
       oldpoint = (MvdPoint*) cl1->At(i);

       Int_t 
	 index = oldpoint->GetTrackID() + offset;

       oldpoint->SetTrackID(index);
       new (clref[fPosIndex]) MvdPoint(*oldpoint);
       fPosIndex++;
     }
   std::cout << "-I- MvdDetector: " << cl2->GetEntriesFast() << " merged entries."
	<< std::endl;
}

// -------------------------------------------------------------------------
void MvdDetector::ConstructGeometry()
{
	TString fileName=GetGeometryFileName();
        if(fileName.EndsWith(".geo")){
		ConstructASCIIGeometry();
	}else if(fileName.EndsWith(".root")){
		ConstructRootGeometry();
	}else{
		std::cout<< "Geometry format not supported " <<std::endl;
	}
}

// -------------------------------------------------------------------------
bool MvdDetector::CheckIfSensitive(std::string name)
{
	for (int i = 0; i < fListOfSensitives.size(); i++){
		if (name.find(fListOfSensitives[i]) != std::string::npos)
		return true;
	}
	return false;
}


void MvdDetector::ConstructRootGeometry()
{

	TFile *f=new TFile(GetGeometryFileName().Data());
 	TList *l= f->GetListOfKeys();
	TKey *k=(TKey *) l->At(0);
 	TGeoVolume *Stt2=(TGeoVolume *)k->ReadObj();
	TGeoNode *n=Stt2->GetNode(0);
	TGeoVolume *v1=n->GetVolume();
	TGeoVolume *Cave= gGeoManager->GetTopVolume();
	gGeoManager->AddVolume(v1);
//  v1->RegisterYourself();
  Cave->AddNode(v1,0, n->GetMatrix());
  ExpandNode(n);
        

}

void MvdDetector::ExpandNode(TGeoNode *fN){

	CbmGeoLoader*geoLoad = CbmGeoLoader::Instance();
    	CbmGeoInterface *geoFace = geoLoad->getGeoInterface();
	CbmGeoMedia *Media =  geoFace->getMedia();
	CbmGeoBuilder *geobuild=geoLoad->getGeoBuilder();

       // TList *MediaArray1=gGeoManager->GetListOfMedia();
	TGeoVolume *v1=fN->GetVolume();
	//v1->RegisterYourself();
  TObjArray *NodeList=v1->GetNodes();
	//Int_t medId=MediaArray1->GetSize();
  	for (Int_t Nod=0; Nod<NodeList->GetEntriesFast();Nod++) {		
		TGeoNode *fNode =(TGeoNode *)NodeList->At(Nod);
    if(fNode->GetNdaughters()>0) ExpandNode(fNode);
		TGeoVolume *v= fNode->GetVolume();
		Int_t MatId=0;
		TGeoMedium* med1=v->GetMedium();
		if(med1){
			TGeoMaterial*mat1=v->GetMaterial(); 
			TGeoMaterial *newMat = gGeoManager->GetMaterial(mat1->GetName());
			if( newMat==0){
				std::cout<< "Material " << mat1->GetName() << " is not defined " << std::endl;
				CbmGeoMedium *CbmMedium=Media->getMedium(mat1->GetName());
				if (!CbmMedium) {
					std::cout << "Material is not defined in ASCII file nor in Root file" << std::endl;
					CbmMedium=new CbmGeoMedium(mat1->GetName());
					Media->addMedium(CbmMedium);
				}
				std::cout << "Create Medium " << mat1->GetName() << std::endl;
				Int_t nmed=geobuild->createMedium(CbmMedium);
				v->SetMedium(gGeoManager->GetMedium(nmed));
				gGeoManager->SetAllIndex();
				
			}else{
				TGeoMedium *med2= gGeoManager->GetMedium(mat1->GetName());
				v->SetMedium(med2);
			}
		}
		if (!gGeoManager->FindVolumeFast(v->GetName())) {
		//	if (fVerboseLevel>2)std::cout << "Register Volume : " << v->GetName() << " id "  << std::endl;
			v->RegisterYourself();
		}
		if (CheckIfSensitive(v->GetName())){
			if (fVerboseLevel>2)std::cout << "Sensitive Volume : " << v->GetName() << " id "  << std::endl;
				AddSensitiveVolume(v);
		}
		
	}
}


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


// -----   Public method ConstructGeometry   -------------------------------
void MvdDetector::ConstructASCIIGeometry()
{
  // get pointer to the instantons which interface 
  // to monte carlo

  CbmGeoLoader *geoLoad = CbmGeoLoader::Instance();
  CbmGeoInterface *geoFace = geoLoad->getGeoInterface();
  MvdGeo *theMvdGeo  = new MvdGeo();

  theMvdGeo->setGeomFile(GetGeometryFileName());
  geoFace->addGeoModule(theMvdGeo);

  Bool_t rc = geoFace->readSet(theMvdGeo);

  if (rc) 
    theMvdGeo->create(geoLoad->getGeoBuilder());

  TList* volList = theMvdGeo->getListOfVolumes();

  // store geo parameter
  CbmRun *fRun = CbmRun::Instance();

  CbmRuntimeDb *rtdb= CbmRun::Instance()->GetRuntimeDb();

  MvdGeoPar *par= (MvdGeoPar*)(rtdb->getContainer("MvdGeoPar"));

  TObjArray *fSensNodes = par->GetGeoSensitiveNodes();

  TObjArray *fPassNodes = par->GetGeoPassiveNodes();

  TListIter iter(volList);

  CbmGeoNode   *node = NULL;
  CbmGeoVolume *aVol = NULL;

  while( (node = (CbmGeoNode*)iter.Next()) ) {
      aVol = dynamic_cast<CbmGeoVolume*> ( node );
       if ( node->isSensitive()  ) {
           fSensNodes->AddLast( aVol );
       }else{
           fPassNodes->AddLast( aVol );
       }
  }

  par->setChanged();
  par->setInputVersion(fRun->GetRunId(),1);

  ProcessNodes ( volList );
}
// -------------------------------------------------------------------------


// -----   Private method AddHit   -----------------------------------------
MvdPoint* MvdDetector::AddHit(Int_t trackID, Int_t detID, TString detName, TVector3 posIn, TVector3 posOut,
			    			TVector3 momIn, TVector3 momOut, 
			    			Double_t time, Double_t length, Double_t eLoss) 
{
  TClonesArray& 
    clref = *fMvdCollection;

  Int_t 
    size = clref.GetEntriesFast();
    
    if (fVerboseLevel == 2)
       std::cout << "-I- MvdDetector: Adding Point at (" << posIn.X() << ", " << posIn.Y()
	    << ", " << posIn.Z() << ") cm,  detector " << detName << " " << detID << ", track "
	    << trackID << ", energy loss " << eLoss*1e06 << " keV" << std::endl;
	 
  return new(clref[size]) MvdPoint(trackID, detID, detName, posIn, posOut,
				      				  momIn, momOut, time, length, eLoss);
}
// -------------------------------------------------------------------------



ClassImp(MvdDetector)