//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
/// \file SinglePlasticEventAction.cc
/// \brief Implementation of the SinglePlasticEventAction class

#include "SinglePlasticDetectorConstruction.hh"
#include "SinglePlasticEventAction.hh"
#include "SinglePlasticRunAction.hh"
#include "SinglePlasticSteppingAction.hh"
#include "SinglePlasticHit.hh"

#include "SinglePlasticSiPMHit.hh"
#include "G4SDManager.hh"
#include "G4Event.hh"
#include "G4RunManager.hh"
#include "G4UnitsTable.hh"

#include "globals.hh"

#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"

using namespace std;
#include <map>

#include <mutex>
#include "G4AutoLock.hh"
std::mutex treeMutex;
G4int eventBegin=0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

G4int SinglePlasticEventAction::SinglePlasticCollectionID = -1;
G4int SinglePlasticEventAction::SinglePlasticSiPMCollectionID = -1;

SinglePlasticRunAction* SinglePlasticEventAction::fRunAction=nullptr;
SinglePlasticEventAction::SinglePlasticEventAction(SinglePlasticRunAction* runAction)
: G4UserEventAction(),
  fEdep(0.)
{

} 

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

SinglePlasticEventAction::~SinglePlasticEventAction()
{
  //G4cout<< "Interaction Fraction : "<<fStepping->interactionCount <<" "<<fStepping->incidentCount<<" "<<fStepping->GetInteractionFraction()<<G4endl;;

  G4cout<<"No. of Incident photons in 1 :"<<fStepping->incidentCount1<<G4endl;
  G4cout<<"No. of Incident photons in 2 :"<<fStepping->incidentCount2<<G4endl;
  
  }

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void SinglePlasticEventAction::BeginOfEventAction(const G4Event* anEvent)
{
  threadID = G4Threading::G4GetThreadId();

  
  //G4AutoLock lock(&myMutex);
  G4int eventNb = anEvent->GetEventID();
  eventBegin = eventNb;
  fEdep = 0.;

  G4SDManager *SDman = G4SDManager::GetSDMpointer();


    if(SinglePlasticCollectionID < 0)
	SinglePlasticCollectionID= SDman->GetCollectionID("PlasticHitsCollection");
	  //SDman->GetCollectionID("PlasticHitsCollection");
      
    if(SinglePlasticSiPMCollectionID < 0)
      SinglePlasticSiPMCollectionID =SDman->GetCollectionID("PlasticSiPMHitsCollection");
    //SDman->GetCollectionID("PlasticSiPMHitsCollection");
      //  }

      
    //fRunAction= SinglePlasticRunAction::GetSharedInstance();
    fRunAction = (SinglePlasticRunAction*)G4RunManager::GetRunManager()->GetUserRunAction();

    //fRunAction = fRunAction->GetSharedInstance();
    
    //G4cout<<fRunAction<<"HHHH"<<G4endl; 
    fDetConst= (SinglePlasticDetectorConstruction*)G4RunManager::GetRunManager()->GetUserDetectorConstruction();

    fStepping = (SinglePlasticSteppingAction*)G4RunManager::GetRunManager()->GetUserSteppingAction();
  
    fStepping->n_scint1=0;
    fStepping->n_opabs1=0;
    fStepping->n_scint2=0;
    fStepping->n_opabs2=0;
    
  G4cout<<"-------- Event : "<<eventNb<<" Starts ------------>"<<G4endl;
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void SinglePlasticEventAction::EndOfEventAction(const G4Event* anEvent)
{
  //  G4AutoLock lock(&myMutex);
  G4int eventNb = anEvent->GetEventID();
  // accumulate statistics in run action
  // fRunAction->AddEdep(fEdep);

  G4HCofThisEvent *HCE = anEvent->GetHCofThisEvent();
  SinglePlasticHitsCollection* WDHC=NULL;
  SinglePlasticSiPMHitsCollection *SIPMHC=NULL;
  G4double posx=0, posy=0, posz=0;
  // G4int ModuleID[2]={0}, DetectID[64]={0};
  //-------- collection ID for NaI crystal

  // G4cout<<"EEE"<< G4endl;// G4SDManager::GetSDMpointer()->ListTree() ;
  
  if(SinglePlasticCollectionID < 0)
      {
	G4cout<<" Collection ID is not assigned to the detectors !!!"<<G4endl;
	return;
      }
  else if(HCE)
      WDHC=(SinglePlasticHitsCollection*)(HCE->GetHC(SinglePlasticCollectionID));
    else
      {
	G4Exception("SinglePlasticEventAction::EndOfEventAction","SinglePlasticCollection Container is NULL",FatalException,"");
      }
    
    if(WDHC==NULL)
      {
	G4Exception("SinglePlasticEventAction::EndOfEventAction","SinglePlasticCollection ID is NULL",FatalException,"\tCheck the collection name string");
      }



    //-------- collection ID for SiPM....
  if(SinglePlasticSiPMCollectionID < 0)
      {
	G4cout<<" Collection ID is not assigned to the detectors !!!"<<G4endl;
	return;
      }
  else if(HCE)
    SIPMHC=(SinglePlasticSiPMHitsCollection*)(HCE->GetHC(SinglePlasticSiPMCollectionID));
  else
    {
      G4Exception("SinglePlasticEventAction::EndOfEventAction","SinglePlasticCollection Container is NULL",FatalException,"");
    }
  
  if(SIPMHC==NULL)
    {
      G4Exception("SinglePlasticEventAction::EndOfEventAction","SinglePlasticCollection ID is NULL",FatalException,"\tCheck the collection name string");
    }

   
    G4int nofhits1 = WDHC->entries();

    if(!nofhits1) return;
    G4double engDep=0, energySum=0, X=0, Y=0, Z=0, SumEn1=0, SumEn2=0;
    G4String particleName;
    G4int ModuleID=0, OldModuleID=-1, totModules=0;
    G4int DetID=0, OldDetID=-1, totDets=0, hitcount=0;
    G4double AvgX=0, AvgY=0, AvgZ=0, time=0, AvgTime=0, gammatime1=0, gammatime2=0;

    // G4cout<< "Average Time :" <<G4BestUnit(fStepping->GetAverageTime(),"Time") <<" "<<"no of hits :"<<nofhits1<<G4endl;

    //G4int threadID = G4Threading::G4GetThreadId();
    
    for(int hitID =0; hitID < nofhits1; hitID++)
      {
	SinglePlasticHit *hithappens = (*WDHC)[hitID];
	//particleName = hithappens->GetParticleName();
	//if(hithappens->GetModuleID()==0 && hithappens->GetEdep()>0)
	if(hithappens->GetVolumeName() == "DetectPhysVol1" && hithappens->GetEdep()>0){
	    SumEn1 += hithappens->GetEdep();
	    gammatime1 += hithappens->GetTime();
	  }
	else if (hithappens->GetVolumeName() == "DetectPhysVol2" && hithappens->GetEdep()>0) {
	  SumEn2 += hithappens->GetEdep();
	  gammatime2 += hithappens->GetTime();
	}
	//else if(hithappens->GetModuleID()==1 && hithappens->GetEdep()>0)
	  
      }
    //G4cout<<nofhits1<<endl;
   
    //SinglePlasticRunAction* fRunAction = static_cast<SinglePlasticRunAction*>(G4RunManager::GetRunManager()->GetUserRunAction());

    if(!fRunAction) {G4cout<<"NULLLLL"<<G4endl; exit(1);}
    G4int tentries = SIPMHC->entries();
    G4int MCID = 0;
    G4double tcounts=0, NScint = fStepping->n_scint1;
    G4int MCIDOld=-1;
    G4int nofmdfires=-1, ten1=0, ten2=0;
    if(tentries)
      {

	ClearRunActionVectors();

	for(int entry=0; entry < tentries; entry++)
	  {
	    SinglePlasticSiPMHit *hit = (*SIPMHC)[entry];
	    MCID = hit->GetModuleCID();
	    
	    int pixelnb = hit->GetPixelNumber();
	    tcounts = hit->GetCounts();
	    
	    if(MCID==0)
	      {
		fRunAction->SiPMxPos1.push_back(hit->GetPosition().getX());
		fRunAction->SiPMyPos1.push_back(hit->GetPosition().getY());
		
		fRunAction->OpticalTime1.push_back(hit->GetOpticalTime());
		fRunAction->OpticalLength1.push_back(hit->GetOpticalLength());
		fRunAction->IncidentAngle1.push_back(hit->GetBoundaryAngle());
		//fRunAction->TimeEmission1.push_back(hit->GetEmissionTime());
		fRunAction->Wavel1.push_back(hit->GetWavel());
		fRunAction->SiPMHitTrackID1.push_back(hit->GetTrackID());
		}
		
	      
	    
	    if(MCID==1)
	      {
		fRunAction->SiPMxPos2.push_back(hit->GetPosition().getX());
		fRunAction->SiPMyPos2.push_back(hit->GetPosition().getY());
		fRunAction->OpticalTime2.push_back(hit->GetOpticalTime());
		fRunAction->OpticalLength2.push_back(hit->GetOpticalLength());
		fRunAction->IncidentAngle2.push_back(hit->GetBoundaryAngle());
		//fRunAction->TimeEmission2.push_back(hit->GetEmissionTime());
		fRunAction->Wavel2.push_back(hit->GetWavel());
		fRunAction->SiPMHitTrackID2.push_back(hit->GetTrackID());
		}
		
	  }
      }
	  
	//G4cout<<fRunAction->SiPMxPos1.size()<<" "<<fRunAction->SiPMxPos2.size()<<" "<<ten1<<" "<<ten2<<G4endl;
	

    
    //if(tentries)
    //{
    if(SumEn1 && SumEn2)// fStepping->GetAverageTime(0)&&fStepping->GetAverageTime(1)))
	  {
	    // G4cout<<"No. of optical photons recieved :"<<tcounts<<" "<<NScint<<" "<<tcounts / NScint<<G4endl;
	    G4cout<<"No. of optical absorption(1) :"<<fStepping->n_opabs1 << " "<<fStepping->n_scint1<<" "<<SumEn1<<G4endl;
	    G4cout<<"No. of optical absorption(2) :"<<fStepping->n_opabs2 << " "<<fStepping->n_scint2<<" "<<SumEn2<<G4endl;
	    G4cout<<" "<<"(1) "<<SumEn1<<" "<<gammatime1<<" "<<fStepping->tspread1.size()<<G4endl;
	    G4cout<<" "<<"(2) "<<SumEn2<<" "<<gammatime2<<" "<<fStepping->tspread2.size()<<G4endl;

	    // G4cout<<fStepping->tspread1.size()<<" "<<fStepping->tspread2.size()<<G4endl;
	    fRunAction->energyDep1 =  SumEn1;
	    fRunAction->energyDep2 =  SumEn2;

	    fRunAction->gamtime1 = gammatime1 / nofhits1;
	    fRunAction->gamtime2 = gammatime2 / nofhits1;

	    fRunAction->OptTridDT1 = fStepping->tspread1;
	    fRunAction->OptTridDT2 = fStepping->tspread2;
	    
	    
	    
	    fRunAction->NScint1 = fStepping->n_scint1;
	    fRunAction->NOpAbs1 = fStepping->n_opabs1;

	    fRunAction->NScint2 = fStepping->n_scint2;
	    fRunAction->NOpAbs2 = fStepping->n_opabs2;
	    
	    //G4double collectionfr = (G4double)(tcounts/NScint);
	    //fRunAction->colleff = collectionfr;
	    //if(fStepping->GetAverageTime())
	    fRunAction->avgtime1 = fStepping->GetAverageTime(0);
	    fRunAction->avgtime2 = fStepping->GetAverageTime(1);
	    
	    G4cout<<"Average optical time 1 :"<<fStepping->GetAverageTime(0)<<G4endl;
	    G4cout<<"Average optical time 2 :"<<fStepping->GetAverageTime(1)<<G4endl;
	    
	    //G4cout<<"Energy Sum1 :"<<SumEn1<<" "<<tentries<<" "<<G4endl;
	    //  }
	    //fRunAction->IntFrac = fStepping->GetInteractionFraction();
	    
	    //if(threadID==0)
	    
	    // Lock the mutex before accessing the shared TTree
	    //std::lock_guard<std::mutex> lock(treeMutex);
	    fRunAction->txTree->Fill();
	  }
	//}
    ClearPreviousEvent();

    G4cout<<"-------- Event :"<<eventNb<<" Ends ------------>"<<G4endl;
}

void SinglePlasticEventAction::ClearPreviousEvent()
{



 
  
  DetIDEnergyVec.clear();
  DetIDCheck.clear();
  fStepping->photonCount1=0;
  fStepping->photonCount2=0;
  fStepping->totalTime1=0;
  fStepping->totalTime2=0;
  fStepping->n_opabs1 = 0;
  fStepping->n_scint1=0;
  fStepping->n_opabs2 = 0;
  fStepping->n_scint2=0;
  fStepping->tspread1.clear();
  fStepping->tspread2.clear();
  // tspread1.clear();
  //tspread2.clear();
  
  //fStepping->incidentCount=0;
  //fStepping->interactionCount=0;
}

void SinglePlasticEventAction::ClearRunActionVectors()
{

   //fRunAction->energyDep.clear();
  fRunAction->xpos.clear();
  fRunAction->ypos.clear();
  fRunAction->zpos.clear();
  fRunAction->SiPMxPos1.clear();
  fRunAction->SiPMxPos1.clear();
  fRunAction->SiPMyPos2.clear();
  fRunAction->SiPMyPos2.clear();
  fRunAction->ModuleID.clear();
  fRunAction->DetectID.clear();
  fRunAction->SiPMModuleID.clear();
  fRunAction->Time.clear();
  fRunAction->OpticalTime1.clear();
  fRunAction->OpticalTime2.clear();
  fRunAction->OpticalTrackID1.clear();
  fRunAction->OpticalTimeDelta1.clear();
  fRunAction->OpticalTrackID2.clear();
  fRunAction->OpticalTimeDelta2.clear();
  fRunAction->SiPMHitTrackID1.clear();
  fRunAction->SiPMHitTrackID2.clear();
  fRunAction->OptTridDT1.clear();
  fRunAction->OptTridDT2.clear();


  //fRunAction->SiPMxPos1.clear();
  //fRunAction->SiPMyPos1.clear();
  
  //fRunAction->SiPMxPos2.clear();
  //fRunAction->SiPMyPos2.clear();
  //fRunAction->OpticalTime1.clear();
  fRunAction->OpticalLength1.clear();
  fRunAction->IncidentAngle1.clear();
  
  //fRunAction->OpticalTime2.clear();
  fRunAction->OpticalLength2.clear();
  fRunAction->IncidentAngle2.clear();
  
  fRunAction->Wavel1.clear();
  fRunAction->Wavel2.clear();
  
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......