#include "NeuDetG4/RootEvent.hh"
#include "NeuDetG4/EventInfo.hh"

#include "CLHEP/Units/SystemOfUnits.h"

#define BIG_VALUE  99999

using namespace CLHEP;

ClassImp(neudet::Primary)
ClassImp(neudet::ScinStripHit)
ClassImp(neudet::RootConf)
ClassImp(neudet::RootEvent)

#include <map>

namespace neudet {

void RootConf::Set(const char* prop_section_, const char* prop_name_, 
						 const char* prop_value_)
{
  if (strlen(prop_section_)>=PROP_LEN) {
	 strncpy(fPropSection,prop_section_,PROP_LEN-1); fPropSection[PROP_LEN-1]='\0';
	 std::cout << "RootConf::Set: warning: too long property section='" << prop_section_ <<
		"' was saved as='" << &fPropSection[0] << "' (increase PROP_LEN in RootEvent.hh " << 
		"for bigger buffer)!\n";
  }
  else
	 sprintf(fPropSection,"%s",prop_section_);

  if (strlen(prop_name_)>=PROP_LEN) {
	 strncpy(fPropName,prop_name_,PROP_LEN-1); fPropName[PROP_LEN-1]='\0';
	 std::cout << "RootConf::Set: warning: too long property name='" << prop_name_ <<
		"' was saved as='" << &fPropName[0] << "' (increase PROP_LEN in RootEvent.hh " << 
		"for bigger buffer)!\n";
  }
  else
	 sprintf(fPropName,"%s",prop_name_);

  if (strlen(prop_value_)>=PROP_LEN) {
	 strncpy(fPropValue,prop_value_,PROP_LEN-1); fPropValue[PROP_LEN-1]='\0';
	 std::cout << "RootConf::Set: warning: too long property value='" << prop_value_ <<
		"' was saved as='" << &fPropValue[0] << "' (increase PROP_LEN in RootEvent.hh " << 
		"for bigger buffer)!\n";
  }
  else
	 sprintf(fPropValue,"%s",prop_value_);

} // end of RootConf::Set

void Primary::SetParticleName(const char* sname)
{
  if (strlen(sname)>=PNAME_LEN) {
	 std::ostringstream message;
	 message << "Primary::SetParticleName: too long name of particle='" <<
		sname << "'! Increase PNAME_LEN parameter!";
	 throw std::runtime_error(message.str());
  }
  sprintf(fParticleName,"%s",sname);
}

void ScinStripHit::SetParticleName(const char* sname)
{
  if (strlen(sname)>=PNAME_LEN) {
	 std::ostringstream message;
	 message << "ScinStripHit::SetParticleName: too long name of particle='" <<
		sname << "'! Increase PNAME_LEN parameter!";
	 throw std::runtime_error(message.str());
  }
  sprintf(fParticleName,"%s",sname);
}

void Primary::DumpInfo(std::ostream & out_ ) const
{
  out_ << "particle name="       << this->fParticleName
		 << "  " << "time="       << this->fTime 
		 << "  " << "kinenergy="  << this->fKinEnergy 
		 << "  " << "vertex.x="   << this->fVertex[0] 
		 << "  " << "vertex.y="   << this->fVertex[1] 
		 << "  " << "vertex.z="   << this->fVertex[2] 
		 << "  " << "momentum.x=" << this->fMomentum[0] 
		 << "  " << "momentum.y=" << this->fMomentum[1] 
		 << "  " << "momentum.z=" << this->fMomentum[2] << "\n";
} // end of Primary::DumpInfo

void ScinStripHit::DumpInfo(std::ostream & out_ ) const
{
  out_ << "Strip ID (X=" << this->fStripXId << ", Y=" << this->fStripYId
		 << ", Z=" << this->fStripZId << ")"
		 << "  " << "particle="         << this->fParticleName
		 << "  " << "time="             << this->fTime 
		 << "  " << "deposited energy=" << this->fEnergyDeposit/keV << " keV";
  if (this->fEnDepAlpha>0)
	 out_	<< "  " << "  by alpha=" << this->fEnDepAlpha << " MeV";
  out_ << "\n";

  if (!fEDepMap.size()) return;

  out_ << "  " << "Edep map (particle name/energy,MeV):";
  for (mapedep_i it = fEDepMap.begin(); it != fEDepMap.end(); it++)
  	 out_ << " " << (*it).first << "/" << (*it).second;
  out_ << "\n";
  
} // end of ScinStripHit::DumpInfo  

void RootEvent::DumpInfo(std::ostream & out_ ) const
{
  out_ << "NeuDetG4 Event in ROOT format:\n";
  out_ << "\nRunID=" << this->fRunNumber << ", EventID=" << fEventNumber << "\n";
  out_ << "\n  Primaries:\n";
  for (Int_t i=0; i<fPrimaries.size(); i++){
	 std::ostringstream message; fPrimaries[i].DumpInfo(message);
	 out_ << i << ". " << message.str();
  }
  out_ << "\n Scintillator strips:\n";
  if (fScinStrip.size()) {
	 out_ << "\n  SC1:\n";
	 for (Int_t i=0; i<fScinStrip.size(); i++){
		std::ostringstream message; fScinStrip[i].DumpInfo(message);
		out_ << i << ". " << message.str();
	 }
  }
  if (fScin2Strip.size()) {
	 out_ << "\n  SC2:\n";
	 for (Int_t i=0; i<fScin2Strip.size(); i++){
		std::ostringstream message; fScin2Strip[i].DumpInfo(message);
		out_ << i << ". " << message.str();
	 }
  }

  out_ << "\n  Neutron capture data: material flag=" << fMaterial << 
	 " at time=" << fCaptTime/ns << " ns, position (X=" << fCaptPos[0] << ", Y=" << 
	 fCaptPos[1] << ", Z=" << fCaptPos[2] << "), Strip[" <<
	 fNStrip[0] << "," << fNStrip[1] << "," << fNStrip[2] << "]\n";

} // end of RootEvent::DumpInfo  


void RootEvent::Reset() 
{
  // Reset neutron data
  
  fRunNumber=fEventNumber=-1;
  fMaterial=-1; fCaptTime=0;
  for (int i=0;i<3;i++) {
	 fIniPos[i]=fCaptPos[i]=BIG_VALUE;	 
	 fNStrip[i]=-1;
  }
  fPrimaries.clear();
  fScinStrip.clear();
  fScin2Strip.clear();
  fEneGamma.clear();
}

  // RootEvent & RootEvent::operator=(EventInfo &ev_ )
RootEvent & RootEvent::operator=(void* ev_ptr )
{  
  bool my_verbose=false;
  //  my_verbose=true;

  EventInfo *ev_ = (EventInfo*) ev_ptr;

  Reset();

  fRunNumber =   ev_->GetId().GetRunNumber();
  fEventNumber = ev_->GetId().GetEventNumber();

  // PROCESS PRIMARIES
  neudet::PrimaryParticle::particles_t *pp_list = ev_->GetPrimaries();
  fPrimaries.clear();
  for (neudet::PrimaryParticle::particles_t::iterator pp_it = pp_list->begin();
		 pp_it != pp_list->end(); pp_it++) {
	 neudet::PrimaryParticle pp_in=(*pp_it);          // take from NeuDetG4-event class
    neudet::Primary pp_out;                          // put into ROOT-event class
	 for (int j=0; j<3; j++) pp_out.SetVertex(j,(pp_in.GetVertex())[j]);
	 for (int j=0; j<3; j++) pp_out.SetMomentum(j,(pp_in.GetMomentum())[j]);
	 pp_out.SetParticleName(pp_in.GetParticleName().c_str());
	 pp_out.SetTime(pp_in.GetTime());
	 pp_out.SetKinEnergy(pp_in.GetKinEnergy());
	 if (my_verbose) {
		std::cout << "\n****** PRIMARIES ******\n";		
		{ 
		  std::ostringstream message;
		  pp_in.Dump(message);
		  std::cout << "*** INPUT NEUDETG4 DATA:\n" << message.str();
		}
		{ 
		  std::ostringstream message;
		  pp_out.DumpInfo(message);
		  std::cout << "*** INPUT ROOT DATA:\n" << message.str();
		}
	 }
	 fPrimaries.push_back(pp_out);
  }

  // PROCESS SCINTILLATOR STRIPS
  
  fScinStrip.clear(); fScin2Strip.clear();

  for (int isc=0; isc<2; isc++) {   // isc=0/1 -> SC1/SC2 hits
	 
	 neudet::SimEvent::scinstrip_data_list_t *sstrip_list = (!isc) 
		? ev_->GetScinStripData()                // SC1 hits
		: ev_->GetScin2StripData();              // SC2 hits

	 for (neudet::SimEvent::scinstrip_data_list_t::iterator sstrip_it = sstrip_list->begin();
			sstrip_it != sstrip_list->end(); sstrip_it++) {
		neudet::SimEvent::scinstrip_data_t 
		  sstrip_in=(*sstrip_it);                // take from NeuDetG4-event class
		neudet::ScinStripHit sstrip_out;         // put into ROOT-event class
	 
		sstrip_out.SetStripXId(sstrip_in.fId1);
		sstrip_out.SetStripYId(sstrip_in.fId2);
		sstrip_out.SetStripZId(sstrip_in.fId3);
		sstrip_out.SetParticleName(sstrip_in.fParticleName.c_str());
		sstrip_out.SetTime(sstrip_in.fTimeFirst);
		sstrip_out.SetEnergyDeposit(sstrip_in.fEnergyDeposit);
		sstrip_out.SetEnDepAlpha(sstrip_in.fEnDepAlpha);
		sstrip_out.SetEDepMap(sstrip_in.fEDepMap);
		for (int j=0; j<3; j++) sstrip_out.SetPosIni(j,sstrip_in.fPos0[j]);

		if (!isc) 
		  fScinStrip.push_back(sstrip_out);
		else
		  fScin2Strip.push_back(sstrip_out);		  
	 }
  }

  // PROCESS NEUTRON DATA
  for (int j=0; j<3; j++) fIniPos[j]=ev_->fIniPos[j];
  for (int j=0; j<3; j++) fCaptPos[j]=ev_->fCaptPos[j];
  for (int j=0; j<3; j++) fNStrip[j]=ev_->fNStrip[j];
  fCaptTime=ev_->fCaptTime;
  fMaterial=ev_->fMaterial;
  fCaptTime=ev_->fCaptTime;
  fEneGamma=ev_->fEneGamma;

  if (my_verbose) {
	 std::ostringstream message;
	 message << "\n ROOT-converted event:\n";
	 DumpInfo(message);
	 std::cout << message.str();
  }
  
  return(*this);
}

}