// -------------------------------------------------------------------------
// -----                PndMvdIdealTrackingTask source file             -----
// -----                  Created 20/03/07  by R.Kliemt               -----
// -------------------------------------------------------------------------
// libc includes
#include <iostream>

// Root includes
#include "TROOT.h"
#include "TString.h"
#include "TClonesArray.h"
#include "TParticlePDG.h"

// framework includes
#include "CbmRootManager.h"
#include "PndMvdIdealTrackingTask.h"
#include "CbmRunAna.h"
#include "CbmRuntimeDb.h"
#include "../mcstack/CbmMCTrack.h"


// PndMvd includes
#include "PndMvdRecoHit.h"
// #include "PndMvdTrackCand.h"
#include "Track.h"
#include "PndMvdHit.h"

// -----   Default constructor   -------------------------------------------
PndMvdIdealTrackingTask::PndMvdIdealTrackingTask() :
  CbmTask("Digitization task for PANDA PndMvd") 
{
	fBranchName 	= "MVDCluster";
}
// -------------------------------------------------------------------------



// -----   Destructor   ----------------------------------------------------
PndMvdIdealTrackingTask::~PndMvdIdealTrackingTask()
{
}

// -----   Public method Init   --------------------------------------------
InitStatus PndMvdIdealTrackingTask::Init()
{
  // Get RootManager
  CbmRootManager* ioman = CbmRootManager::Instance();
  if ( ! ioman ) {
    std::cout << "-E- PndMvdIdealTrackingTask::Init: "<< "RootManager not instantiated!" << std::endl;
    return kFATAL;  }

  // Get input array
  fHitArray = (TClonesArray*) ioman->GetObject(fBranchName);
  if ( ! fHitArray ) {
    std::cout << "-W- PndMvdIdealTrackingTask::Init: "<< "No "<<fBranchName<<" array!" << std::endl;
    return kERROR;  }

  // Get MCTruth collection
  fMctruthArray=(TClonesArray*) ioman->GetObject("MCTrack");
  if(fMctruthArray==0)  {
    std::cout << "-W- PndMvdIdealTrackingTask::Init: "<< "No McTruth array!" << std::endl;
    return kERROR;  }

  // Create and register output array
  fTrackOutputArray = new TClonesArray("Track");
  ioman->Register("PndMvdTracks", "PndMvd ideal tracklets", fTrackOutputArray, kTRUE);


  return kSUCCESS;
}
// -------------------------------------------------------------------------
void PndMvdIdealTrackingTask::SetParContainers()
{
  // Get Base Container
  CbmRunAna* ana = CbmRunAna::Instance();
  CbmRuntimeDb* rtdb=ana->GetRuntimeDb();

}


// -----   Public method Exec   --------------------------------------------
void PndMvdIdealTrackingTask::Exec(Option_t* opt)
{
 	if ( ! fTrackOutputArray ) Fatal("Exec", "No fTrackOutputArray");
 	fTrackOutputArray->Clear();

  // CREATE MONTECARLO MAP
  std::map<Int_t, CbmMCTrack*> mcmap;
  Int_t nmc=fMctruthArray->GetEntriesFast();
  for(Int_t imc=0;imc<nmc;++imc){
    CbmMCTrack* mc=(CbmMCTrack*)fMctruthArray->At(imc);
    mcmap[imc]=mc;
  }

  // BUILD TRACK Candidates
  std::map<Int_t, Track*> trackMap;

  Int_t nPndMvdHits=fHitArray->GetEntriesFast();
  for(Int_t iHit=0;iHit<nPndMvdHits;++iHit)
  {

    PndMvdHit* hit=(PndMvdHit*)fHitArray->At(iHit);


    Int_t MCid=hit->GetRefIndex();  //Warning: This is the ID of the MC hit and not the track ID!

    // cut on secondaries (deltas) etc
    if(MCid<0)continue;

    TVector3 pos;
    hit->Position(pos);

    // build tracks here:

    // check if track already candidated:
    if(trackMap[MCid]==0)
    {
			Int_t pdgcode = mcmap[MCid]->GetPdgCode();
			TParticlePDG pdgpart(pdgcode);
			Int_t mcCharge = (Int_t)pdgpart.Charge();

			TVector3 pos = mcmap[MCid]->GetStartVertex();
			TVector3 mom = mcmap[MCid]->GetMomentum();

			Double_t invp = 1 / mom.Mag();
			Double_t dxdz = invp*mom.x()*mom.z();
			Double_t dydz = invp*mom.y()*mom.z();
			Double_t sigx = 0.01, sigy = 0.01, sigdxdz = 0.01, sigdydz = 0.01, siginvp = 0.01;

			sigx*=pos.x();
			sigy*=pos.y();
			sigdxdz*=dxdz;
			sigdydz*=dydz;
			siginvp*=invp;

			if(fVerbose>1) std::cout<<"PndMvdIdealTrackingTask::Exec(), Particle Info: "
        <<pdgpart.GetName()<<" ("<<pdgcode<<") Q="<<mcCharge<<std::endl;
     
	    Int_t size = fTrackOutputArray->GetEntriesFast();
      trackMap[MCid]=new ((*fTrackOutputArray)[size]) Track();
    }

    /// TODO 1: Get Cluster objects
    // add the hit index
//       trackMap[MCid]->addHit(,hit->GetDetectorID(),iHit);
      PndMvdRecoHit arecohit(hit);

///  TODO use the factory here!!!
///       trackMap[MCid]->addHit(arecohit,1,iHit);

  }//end for hit


  std::cout<<fTrackOutputArray->GetEntriesFast()
		   <<" Tracks created"<<std::endl;



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


ClassImp(PndMvdIdealTrackingTask);