#include "IDatum.hxx"
#include "IRealDatum.hxx"
#include "TPrincipal.h"

#include "IP0DReconECalModule.hxx"

ClassImp(COMET::IP0DReconECalModule);
ClassImp(COMET::IP0DReconECalModule::IP0DReconECalTrack);
ClassImp(COMET::IP0DReconECalModule::IP0DReconECalShower);

#define CVSTAG "\
  $Name: v5r19 $"
#define CVSID  "\
  $Id: IP0DReconECalModule.cxx,v 1.13 2012/06/25 10:01:19 akaboth Exp $"

int GetStackNo(TString Name){
  if(Name.Contains("LS")) return 1; else if(Name.Contains("LT")) return 2; 
  else if(Name.Contains("LB")) return 3; else if(Name.Contains("RS")) return 4; 
  else if(Name.Contains("RT")) return 5; else if(Name.Contains("RB")) return 6;
  else return -1;
}

COMET::IP0DReconECalModule::IP0DReconECalModule(const char *name,
const char *title) {

  SetNameTitle(name, title);
  // Enable this module by default:
  fIsEnabled = kTRUE;
  fDescription = "P0D ECAL recon output";
  fCVSTagName = CVSTAG;
  fCVSID = CVSID;

  this->SetSplitLevel(1); //set splitlevel of trees

  // Tree variables
  fReconTracks = new TClonesArray("COMET::IP0DReconECalModule::IP0DReconECalTrack", 200);
  fReconShowers = new TClonesArray("COMET::IP0DReconECalModule::IP0DReconECalShower", 200);
  fLayerCharge = new TClonesArray("COMET::IP0DReconECalModule::IP0DECALLayerCharge", 200);
}


COMET::IP0DReconECalModule::~IP0DReconECalModule() {}

Bool_t COMET::IP0DReconECalModule::ProcessFirstEvent(COMET::ICOMETEvent& event) {
  return true;
}


void COMET::IP0DReconECalModule::InitializeModule() {
}


void COMET::IP0DReconECalModule::InitializeBranches() {
  // Event Level Recon Info
  fOutputTree->Branch("NReconTracks", &fNReconTracks, "NReconTracks/I", fBufferSize);
  fOutputTree->Branch("NReconShowers", &fNReconShowers, "NReconShowers/I", fBufferSize);
  fOutputTree->Branch("NLayerCharge", &fNLayerCharge, "NLayerCharge/I", fBufferSize);

  // A TClonesArray of IP0DReconECalTrack objects
  fOutputTree->Branch("ReconTracks", &fReconTracks, fBufferSize, fSplitLevel);
  // A TClonesArray of IP0DReconECalShower objects
  fOutputTree->Branch("ReconShowers", &fReconShowers, fBufferSize, fSplitLevel);
  fOutputTree->Branch("LayerCharge", &fLayerCharge, fBufferSize, fSplitLevel);
}


bool COMET::IP0DReconECalModule::FillTree(COMET::ICOMETEvent& event) {

  ///////////////// Add Recon Data ///////////////////////////////////////
  // reset the variables
  fNReconTracks = 0;
  fReconTracks->Clear();
  fNReconShowers = 0;
  fReconShowers->Clear();
  fNLayerCharge = 0;
  fLayerCharge->Clear();

  if(!event.GetFit("P0DECALPid")) { 
    //No P0DECal Info - return blank info
    return true;
  }

  COMET::IHandle<COMET::IAlgorithmResult> ecalFinalResult
    = event.GetFit("P0DECALPid");

  for(COMET::IDataVector::iterator dataIter = ecalFinalResult->begin();
      dataIter != ecalFinalResult->end(); ++dataIter) {

    std::string class_name = (*dataIter)->ClassName();
    if(class_name.find("COMET::IReconObjectContainer") != std::string::npos) {

      COMET::IReconObjectContainer* reconContainer =
        dynamic_cast<COMET::IReconObjectContainer*>(*dataIter);

      if(!reconContainer){
  //No P0DECal Info - return blank info
  return true;
      }
      
      // Should be called final
      TString reconContainerName = reconContainer->GetFullName();
      //      int stackNo = GetStackNo(reconContainerName);
      
      if(reconContainerName.Contains("final"))
      {
   // Loop over the top level Recon Container - ReconPid's
   for(COMET::IReconObjectContainer::iterator reconIter =
    reconContainer->begin();
       reconIter != reconContainer->end();  ++reconIter) {
      
      std::string reco_class_name = (*reconIter)->ClassName();
      
      // Get the TReconPid from the container
      if(reco_class_name.find("COMET::IReconPID") != std::string::npos) {
         
         COMET::IHandle<COMET::IReconPID> pid = (*reconIter);
         COMET::IHandle<COMET::IReconObjectContainer> conContainer = pid->GetConstituents();
         
         for(COMET::IReconObjectContainer::iterator conIter =
          conContainer->begin();
       conIter != conContainer->end();  ++conIter) {
      
      std::string constituent_class_name = (*conIter)->ClassName();
      
      if(constituent_class_name.find("COMET::IReconTrack") != std::string::npos) {
         
         COMET::IHandle<COMET::IReconTrack> track = (*conIter);
         IP0DReconECalTrack *ReconECalTrack = 0;
         
         if(track->GetEDeposit()) {
      ReconECalTrack = new((*fReconTracks)[fNReconTracks]) IP0DReconECalTrack;
      
      // Fill UniqueID
      ReconECalTrack->UniqueID = track->GetUniqueID();
      ReconECalTrack->Direction = track->GetDirection();
      ReconECalTrack->Position = track->GetPosition();


      //// Preserved code for track direction/postion determination. Obsolete

// 			COMET::IReconObjectContainer altContainer = pid->GetAlternates();
// 			for(COMET::IReconObjectContainer::iterator altIter =
// 			       altContainer.begin();
// 			    altIter != altContainer.end();  ++altIter) {
// 			   std::string alt_class_name = (*altIter)->ClassName();
         
// 			   if(alt_class_name.find("COMET::IReconPID") != std::string::npos) {
// 			      COMET::IHandle<COMET::IReconPID> alt_pid =  (*altIter);
// 			      COMET::IHandle<COMET::IReconObjectContainer> alt_conContainer = alt_pid->GetConstituents();
            
// 			      for(COMET::IReconObjectContainer::iterator alt_conIter =
// 				     alt_conContainer->begin();
// 				  alt_conIter != alt_conContainer->end();  ++alt_conIter) {
         
// 				 alt_class_name = (*alt_conIter)->ClassName();
         
// 				 if(alt_class_name.find("COMET::IReconShower") != std::string::npos) {
// 				    COMET::IHandle<COMET::IReconShower> sh = (*alt_conIter);
// 				    if(sh->GetEDeposit()) {
// 				       ReconECalTrack->Direction = sh->GetDirection();
// 				       ReconECalTrack->Position = sh->GetPosition();
// 				    }
// 				    else {
// 				       ReconECalTrack->Direction = track->GetDirection();
// 				       ReconECalTrack->Position = track->GetPosition();
// 				    }
// 				 }
// 			      }
// 			   }
// 			}
      ReconECalTrack->StackNo = (int)track->GetDetectors();
      
      // IReconTrack standard Get member functions
      ReconECalTrack->Curvature = track->GetCurvature();
      ReconECalTrack->EDeposit = track->GetEDeposit();
      ReconECalTrack->NDOF = track->GetNDOF();
      ReconECalTrack->Quality = track->GetQuality();
      ReconECalTrack->Width = track->GetWidth();
      
      fNReconTracks++;
      
      // Pid Vars      
      if(track->Get< COMET::IRealDatum >("AMR")) 
         ReconECalTrack->AMR = track->Get< COMET::IRealDatum >("AMR")->GetValue();
      else ReconECalTrack->AMR = -1;
      
      if(track->Get< COMET::IRealDatum >("CWTrackWidth")) 
         ReconECalTrack->CWTrackWidth = track->Get< COMET::IRealDatum >("CWTrackWidth")->GetValue();
      else ReconECalTrack->CWTrackWidth = -1;
      
      if(track->Get< COMET::IRealDatum >("Max_Ratio")) 
         ReconECalTrack->Max_Ratio = track->Get< COMET::IRealDatum >("Max_Ratio")->GetValue();
      else ReconECalTrack->Max_Ratio = -1;
      
      if(track->Get< COMET::IRealDatum >("NormChargeSD")) 
         ReconECalTrack->NormChargeSD = track->Get< COMET::IRealDatum >("NormChargeSD")->GetValue();
      else ReconECalTrack->NormChargeSD = -1;
      
      if(track->Get< COMET::IRealDatum >("PathChargeRatio")) 
         ReconECalTrack->PathChargeRatio = track->Get< COMET::IRealDatum >("PathChargeRatio")->GetValue();
      else ReconECalTrack->PathChargeRatio = -1;
      
      if(track->Get< COMET::IRealDatum >("TrShval")) 
         ReconECalTrack->TrShval = track->Get< COMET::IRealDatum >("TrShval")->GetValue();
      else ReconECalTrack->TrShval = -1;
      
      
      /// If you need any info from the contributing clusters
      COMET::IHandle<COMET::IReconObjectContainer> clusterContainer = track->GetConstituents();
      for(COMET::IReconObjectContainer::iterator clusterIter =
             clusterContainer->begin();
          clusterIter != clusterContainer->end();  ++clusterIter) {
         
         std::string track_constituent_class_name = (*clusterIter)->ClassName();
         if(track_constituent_class_name.find("COMET::IReconCluster") != std::string::npos) {
            
            COMET::IHandle<COMET::IReconCluster> cluster = (*clusterIter);
            
            TVector3 tmpBenCWPos(0,0,0);
            if(cluster->Get< COMET::IRealDatum >("BenCWPos")) {
         std::vector< double > PosVec = cluster->Get< COMET::IRealDatum >("BenCWPos")->GetVector();
         tmpBenCWPos.SetX(PosVec[0]);
         tmpBenCWPos.SetY(PosVec[1]);
         tmpBenCWPos.SetZ(PosVec[2]);
            }
            ReconECalTrack->BenCWPosition = tmpBenCWPos;
            
            // Pid Vars      
            if(cluster->Get< COMET::IRealDatum >("AMR"))
         ReconECalTrack->AMR = cluster->Get< COMET::IRealDatum >("AMR")->GetValue();
            else ReconECalTrack->AMR = -1;
            
            if(cluster->Get< COMET::IRealDatum >("CWTrackWidth"))
         ReconECalTrack->CWTrackWidth = cluster->Get< COMET::IRealDatum >("CWTrackWidth")->GetValue();
            else ReconECalTrack->CWTrackWidth = -1;
            
            if(cluster->Get< COMET::IRealDatum >("Max_Ratio"))
         ReconECalTrack->Max_Ratio = cluster->Get< COMET::IRealDatum >("Max_Ratio")->GetValue();
            else ReconECalTrack->Max_Ratio = -1;
            
            if(cluster->Get< COMET::IRealDatum >("NormChargeSD"))
         ReconECalTrack->NormChargeSD = cluster->Get< COMET::IRealDatum >("NormChargeSD")->GetValue();
            else ReconECalTrack->NormChargeSD = -1;
            
            if(cluster->Get< COMET::IRealDatum >("PathChargeRatio"))
         ReconECalTrack->PathChargeRatio = cluster->Get< COMET::IRealDatum >("PathChargeRatio")->GetValue();
            else ReconECalTrack->PathChargeRatio = -1;
            
// 		    if(cluster->Get< COMET::IRealDatum >("TrShval"))
// 		      ReconECalTrack->TrShval = cluster->Get< COMET::IRealDatum >("TrShval")->GetValue();
// 		    else ReconECalTrack->TrShval = -1;
            ReconECalTrack->NHits = (int)cluster->GetHits()->size();
            
         }
      }
         }
      }
      
      // else is it a shower?
      else if (constituent_class_name.find("COMET::IReconShower") != std::string::npos) {
         
         COMET::IHandle<COMET::IReconShower> shower = (*conIter);
         IP0DReconECalShower *ReconECalShower = 0;
         
         if(shower->GetEDeposit()) {
      ReconECalShower = new((*fReconShowers)[fNReconShowers]) IP0DReconECalShower;
      
      // Fill UniqueID
      ReconECalShower->UniqueID = shower->GetUniqueID();
      
      ReconECalShower->StackNo = (int)shower->GetDetectors();
      
      // IReconShower standard Get member functions
      ReconECalShower->ConeAngle = shower->GetConeAngle();
      ReconECalShower->Direction = shower->GetDirection();
      ReconECalShower->EDeposit = shower->GetEDeposit();
      ReconECalShower->NDOF = shower->GetNDOF();
      ReconECalShower->Position = shower->GetPosition();
      ReconECalShower->Quality = shower->GetQuality();
      fNReconShowers++;
      
      // Pid Vars - Get these from the consituents of which there should be just one for p0decal objects
      if(shower->Get< COMET::IRealDatum >("AMR")) 
         ReconECalShower->AMR = shower->Get< COMET::IRealDatum >("AMR")->GetValue();
      else ReconECalShower->AMR = -1;
      
      if(shower->Get< COMET::IRealDatum >("CWTrackWidth")) 
         ReconECalShower->CWTrackWidth = shower->Get< COMET::IRealDatum >("CWTrackWidth")->GetValue();
      else ReconECalShower->CWTrackWidth = -1;
      
      if(shower->Get< COMET::IRealDatum >("Max_Ratio")) 
         ReconECalShower->Max_Ratio = shower->Get< COMET::IRealDatum >("Max_Ratio")->GetValue();
      else ReconECalShower->Max_Ratio = -1;
      
      if(shower->Get< COMET::IRealDatum >("NormChargeSD")) 
         ReconECalShower->NormChargeSD = shower->Get< COMET::IRealDatum >("NormChargeSD")->GetValue();
      else ReconECalShower->NormChargeSD = -1;
      
      if(shower->Get< COMET::IRealDatum >("PathChargeRatio")) 
         ReconECalShower->PathChargeRatio = shower->Get< COMET::IRealDatum >("PathChargeRatio")->GetValue();
      else ReconECalShower->PathChargeRatio = -1;
      
      if(shower->Get< COMET::IRealDatum >("TrShval")) 
         ReconECalShower->TrShval = shower->Get< COMET::IRealDatum >("TrShval")->GetValue();
      else ReconECalShower->TrShval = -1;
      
      
      /// If you need any info from the contributing clusters
      COMET::IHandle<COMET::IReconObjectContainer> clusterContainer = shower->GetConstituents();
      for(COMET::IReconObjectContainer::iterator clusterIter =
             clusterContainer->begin();
          clusterIter != clusterContainer->end();  ++clusterIter) {
         
         std::string shower_constituent_class_name = (*clusterIter)->ClassName();
         if(shower_constituent_class_name.find("COMET::IReconCluster") != std::string::npos) {
            
            COMET::IHandle<COMET::IReconCluster> cluster = (*clusterIter);
            
            TVector3 tmpBenCWPos(0,0,0);
            if(cluster->Get< COMET::IRealDatum >("BenCWPos")) {
         std::vector< double > PosVec = cluster->Get< COMET::IRealDatum >("BenCWPos")->GetVector();
         tmpBenCWPos.SetX(PosVec[0]);
         tmpBenCWPos.SetY(PosVec[1]);
         tmpBenCWPos.SetZ(PosVec[2]);
            }
            ReconECalShower->BenCWPosition = tmpBenCWPos;
            
            
            // Pid Vars - Get these from the consituents of which there should be just one for p0decal objects
            if(cluster->Get< COMET::IRealDatum >("AMR"))
         ReconECalShower->AMR = cluster->Get< COMET::IRealDatum >("AMR")->GetValue();
            else ReconECalShower->AMR = -1;
            
            if(cluster->Get< COMET::IRealDatum >("CWTrackWidth"))
         ReconECalShower->CWTrackWidth = cluster->Get< COMET::IRealDatum >("CWTrackWidth")->GetValue();
            else ReconECalShower->CWTrackWidth = -1;
            
            if(cluster->Get< COMET::IRealDatum >("Max_Ratio"))
         ReconECalShower->Max_Ratio = cluster->Get< COMET::IRealDatum >("Max_Ratio")->GetValue();
            else ReconECalShower->Max_Ratio = -1;
            
            if(cluster->Get< COMET::IRealDatum >("NormChargeSD"))
         ReconECalShower->NormChargeSD = cluster->Get< COMET::IRealDatum >("NormChargeSD")->GetValue();
            else ReconECalShower->NormChargeSD = -1;
            
            if(cluster->Get< COMET::IRealDatum >("PathChargeRatio"))
         ReconECalShower->PathChargeRatio = cluster->Get< COMET::IRealDatum >("PathChargeRatio")->GetValue();
            else ReconECalShower->PathChargeRatio = -1;
            
// 		    if(cluster->Get< COMET::IRealDatum >("TrShval"))
// 		      ReconECalShower->TrShval = cluster->Get< COMET::IRealDatum >("TrShval")->GetValue();
// 		    else ReconECalShower->TrShval = -1;
            
            ReconECalShower->NHits = (int)cluster->GetHits()->size();
              
         }
      }
         }
      }
         }
      }
   }
      }
      else if(reconContainerName.Contains("charge_by_layer"))
      {

   
   for(COMET::IReconObjectContainer::iterator reconIter = reconContainer->begin();
       reconIter != reconContainer->end();  ++reconIter) 
   {
      COMET::IHandle<COMET::IReconCluster> cluster = (*reconIter);
       IP0DECALLayerCharge *LayerCharge = 0;
      
      LayerCharge = new((*fLayerCharge)[fNLayerCharge]) IP0DECALLayerCharge;
      fNLayerCharge++;

      LayerCharge->module_name="";
      TString algoname = cluster->GetAlgorithmName();
      if(algoname.Contains("Left"))
         LayerCharge->module_name+="Left";
      if(algoname.Contains("Right"))
         LayerCharge->module_name+="Right";

      LayerCharge->module_name+=" ";
      
      if(algoname.Contains("Top"))
         LayerCharge->module_name+="Top";
      if(algoname.Contains("Bottom"))
         LayerCharge->module_name+="Bottom";
      if(algoname.Contains("Side"))
         LayerCharge->module_name+="Side";

      if(cluster->Get< COMET::IRealDatum >("first_time"))
         LayerCharge->FirstTime = cluster->Get< COMET::IRealDatum >("first_time")->GetValue();
      else 
         LayerCharge->FirstTime = -1;
      
      if(cluster->Get< COMET::IRealDatum >("last_time"))
         LayerCharge->LastTime = cluster->Get< COMET::IRealDatum >("last_time")->GetValue();
      else 
         LayerCharge->LastTime = -1;

      if(cluster->Get< COMET::IRealDatum >("layer_charge"))
      {
         for(int nlay=0; nlay<6; nlay++)
         {
      LayerCharge->Charge[nlay]=cluster->Get< COMET::IRealDatum >("layer_charge")->GetVector()[nlay];
         }
      }
      
   }	      
   
      }
    }
  }
  return true;
}


COMET::IP0DReconECalModule::IP0DReconECalTrack::~IP0DReconECalTrack(){}
COMET::IP0DReconECalModule::IP0DReconECalShower::~IP0DReconECalShower(){}
COMET::IP0DReconECalModule::IP0DECALLayerCharge::~IP0DECALLayerCharge(){}