#ifndef __RootEvent_hh
#define __RootEvent_hh 1

// standard C++ stuff

#include <TObject.h>
#include <TNamed.h>
#include <TString.h>
#include <stdexcept>
#include <stdio.h>
#include <vector>

#include "NeuDetG4/EventInfo.hh"

namespace neudet {

#define PNAME_LEN 20
#define PROP_LEN 5000

  //  class SomeClass: public TObject
  //  {
  //  public:
  //	 SomeClass();
  //
  //	 //Setters definitions
  //	 
  //	 //Getters definitions
  //	 void DumpInfo( std::ostream & out_ ) const;
  //
  //  private:
  //	 Char_t   fParticleName[PNAME_LEN];
  //
  //	 ClassDef(SomeClass,1) // Scintillator bar hit
  //		};
  // don't forget to add ClassImp(neudet::SomeClass) to RootEvent.cc
  // and to neudetg4LinkDef.h the statement:
  // #pragma link C++ class neudet::SomeClass+;
  
  // class to keep configuration information about run executed
  class RootConf: public TNamed
  {
  public:
	 RootConf(){strcpy(fPropSection,""); strcpy(fPropName,""); strcpy(fPropValue,"");}
	 
	 //Setters definitions
	 void Set(const char*, const char*, const char*);
	 
	 void DumpInfo( std::ostream & out_ ) const
	 { out_ << &fPropSection[0] << ": " << &fPropName[0] << "=" << &fPropValue[0];}
	 
	 Char_t   fPropSection[PROP_LEN];
	 Char_t   fPropName[PROP_LEN];
	 Char_t   fPropValue[PROP_LEN];
	 
	 ClassDef(RootConf,1) // Configuration data of property
		};

  class Primary: public TObject
  {
	 
  public: 
	 Primary() {strcpy(fParticleName,"");};
	 
	 //Setters definitions
	 void SetParticleName (const char*);
	 void SetTime (Double_t sTime = 0);
	 void SetKinEnergy (Double_t sKinEnergy = 0);
	 void SetVertex (Int_t i, Double_t sVertex);
	 void SetMomentum (Int_t i, Double_t sMomentum);
	 
	 //Getters definitions
	 Char_t* GetParticleName ();
	 Double_t GetTime ();
	 Double_t GetKinEnergy ();
	 Double_t GetVertex (Int_t i);
	 Double_t GetMomentum (Int_t i);

	 void DumpInfo( std::ostream & out_ ) const;
	 
  public:
	 Char_t       fParticleName[PNAME_LEN];
	 Double_t     fTime;
	 Double_t     fKinEnergy;
	 Double_t     fVertex[3];
	 Double_t     fMomentum[3];
	 
	 ClassDef(Primary,1) // primary particle generated
  };

  //Setters implementations
  inline void Primary::SetTime (Double_t sTime) {fTime=sTime;}
  inline void Primary::SetKinEnergy (Double_t sKinEnergy) {fKinEnergy=sKinEnergy;}
  inline void Primary::SetVertex (Int_t i, Double_t sVertex) {
	 if ((i>=0) && (i<3)) fVertex[i]=sVertex;}
  inline void Primary::SetMomentum (Int_t i, Double_t sMomentum) {
	 if ((i>=0) && (i<3)) fMomentum[i]=sMomentum;}

  //Getters implementations
  inline Char_t* Primary::GetParticleName () {return &fParticleName[0];}
  inline Double_t Primary::GetTime () {return fTime;}
  inline Double_t Primary::GetKinEnergy () {return fKinEnergy;}
  inline Double_t Primary::GetVertex (Int_t i) 
  {return ((i>=0) && (i<3)) ? fVertex[i]: 0.;}
  inline Double_t Primary::GetMomentum (Int_t i) {
	 return ((i>=0) && (i<3)) ? fMomentum[i]: 0.;}
  
  class ScinStripHit: public TObject
  {
  public:
	 ScinStripHit() {strcpy(fParticleName,"");};

	 //Setters definitions
	 void SetStripXId (Int_t sStripXId = 0);
	 void SetStripYId (Int_t sStripYId = 0);
	 void SetStripZId (Int_t sStripZId = 0);
	 void SetParticleName (const char*);
	 void SetTime (Double_t sTime = 0);
	 void SetEnergyDeposit (Double_t sEnergyDeposit = 0);
	 void SetEnDepAlpha (Double_t sEnergyDeposit = 0)
	 {fEnDepAlpha=sEnergyDeposit;}
	 void SetPosIni (Int_t i, Double_t sPosIni) {
	 if ((i>=0) && (i<3)) fPosIni[i]=sPosIni;}
	 
	 //Getters definitions
	 Int_t GetStripXId ();
	 Int_t GetStripYId ();
	 Int_t GetStripZId ();
	 Char_t* GetParticleName ();
	 Double_t GetTime ();
	 Double_t GetEnergyDeposit ();
	 Double_t GetEnDepAlpha () {return fEnDepAlpha;}
	 Double_t GetPosIni (Int_t i) 
	 {return ((i>=0) && (i<3)) ? fPosIni[i]: 0.;}
	 

	 void DumpInfo( std::ostream & out_ ) const;
	 
	 typedef std::map<std::string,double> mapedep_t;
	 typedef mapedep_t::const_iterator mapedep_i;

	 void SetEDepMap(mapedep_t m){fEDepMap=m;}
	 mapedep_t& GetEDepMap(){return fEDepMap;}

  private:

	 Int_t    fStripXId;      // 1-th block index     (X)
	 Int_t    fStripYId;      // 2-th block index     (Y)
	 Int_t    fStripZId;      // 3-th index along bar (Z)
	 Char_t   fParticleName[PNAME_LEN]; // particle name
	 Double_t fPosIni[3];     // Entrance position (at entrance time)
	 Double_t fTime;          // Entrance time
	 Double_t fEnergyDeposit; // total energy deposited
	 Double_t fEnDepAlpha;	  // energy deposited by aplpha
	 mapedep_t  fEDepMap;       // energy deposit map according to particle type
	                          // (map key - particle G4 name)

	 ClassDef(ScinStripHit,1) // Scintillator strip hit
		};

  //Setters implementations
  inline void ScinStripHit::SetStripXId (Int_t sStripXId) {fStripXId=sStripXId;}
  inline void ScinStripHit::SetStripYId (Int_t sStripYId) {fStripYId=sStripYId;}
  inline void ScinStripHit::SetStripZId (Int_t sStripZId) {fStripZId=sStripZId;}
  inline void ScinStripHit::SetTime (Double_t sTime) {fTime=sTime;}
  inline void ScinStripHit::SetEnergyDeposit (Double_t sEnergyDeposit) {
	 fEnergyDeposit=sEnergyDeposit;}
  
  //Getters implementations
  inline Int_t ScinStripHit::GetStripXId () {return fStripXId;}
  inline Int_t ScinStripHit::GetStripYId () {return fStripYId;}
  inline Int_t ScinStripHit::GetStripZId () {return fStripZId;}
  inline Char_t* ScinStripHit::GetParticleName () {return &fParticleName[0];}
  inline Double_t ScinStripHit::GetTime () {return fTime;}
  inline Double_t ScinStripHit::GetEnergyDeposit () {return fEnergyDeposit;}
  
  class RootEvent: public TNamed
  {
  public:
	 
	 //Setters definitions
	 void SetRunNumber (Int_t sRunNumber = 0);
	 void SetEventNumber (Int_t sEventNumber = 0);
	 void SetScinStrip (std::vector<neudet::ScinStripHit> sScinStrip);
	 void SetPrimaries (std::vector<neudet::Primary> sPrimaries);
	 
	 //Getters definitions
	 Int_t GetRunNumber ();
	 Int_t GetEventNumber ();
	 std::vector<neudet::ScinStripHit> GetScinStrip ();
	 std::vector<neudet::Primary> GetPrimaries ();
	 
	 //	 RootEvent & operator=(EventInfo & );
	 RootEvent & operator=(void*);
    void DumpInfo( std::ostream & out_ ) const;
	 
  private:
	 Int_t fRunNumber;
	 Int_t fEventNumber;
	 std::vector<neudet::Primary> fPrimaries;
	 std::vector<neudet::ScinStripHit> fScinStrip;
	 std::vector<neudet::ScinStripHit> fScin2Strip;

  public:
	 // common data
	 Double_t             fIniPos[3];
	 Double_t             fCaptPos[3];
	 Double_t             fCaptTime;
	 Int_t                fMaterial; 
	 Int_t                fNStrip[3]; // strip number (X,Y,Z)
	 std::vector<Double_t>  fEneGamma; // Energies of gammas emitted by n-capture

  public:
	 void Reset();

	 ClassDef(RootEvent,2) // NeuDet event in ROOT format
		};

  //Setters implementations
  inline void RootEvent::SetRunNumber (Int_t sRunNumber) {fRunNumber=sRunNumber;}
  inline void RootEvent::SetEventNumber (Int_t sEventNumber) {fEventNumber=sEventNumber;}
  inline void RootEvent::SetPrimaries (std::vector<neudet::Primary> sPrimaries) {
	 fPrimaries=sPrimaries;}
  inline void RootEvent::SetScinStrip (std::vector<neudet::ScinStripHit> sScinStrip) {
	 fScinStrip=sScinStrip;}
  
  //Getters implementations
  inline Int_t RootEvent::GetRunNumber () {return fRunNumber;}
  inline Int_t RootEvent::GetEventNumber () {return fEventNumber;}
  inline std::vector<neudet::Primary> RootEvent::GetPrimaries () {return fPrimaries;}
  inline std::vector<neudet::ScinStripHit> RootEvent::GetScinStrip () {return fScinStrip;}
  
} // end of namespace neudet 

#endif /* __RootEvent_hh */

// end of RootEvent.hh