#include <iostream>
#include <string>
#include <vector>

#include <TObject.h>
#include <TLorentzVector.h>

class namedRecord {
 public:
  namedRecord() {}
  namedRecord(std::string n) {name_ = n;}
  virtual ~namedRecord() {};

  std::string getRecordName() const {return name_;}
 protected:
  std::string name_;

  ClassDef(namedRecord, 1);

};

class BaseEventRecord : public namedRecord {
 public:
  BaseEventRecord() : pos_(0., 0., 0., 0.) {}

  BaseEventRecord(TLorentzVector pos)
 : pos_(pos) {}

  BaseEventRecord(const BaseEventRecord &e)
  : namedRecord(e.getRecordName()), pos_(e.getPosition()) {}

  virtual ~BaseEventRecord() {};

  TLorentzVector getPosition() const                  {return pos_;}
  void setPosition(TLorentzVector v)                  {pos_ = v;}

  BaseEventRecord& operator=(const BaseEventRecord &e) {
    pos_ = e.getPosition(); return *this;
  }

  // void printToStream(ostream& stream);

protected:
  TLorentzVector pos_;

  ClassDef(BaseEventRecord, 1);
};

class ParticleDescrShortRecord {
 public:
  ParticleDescrShortRecord() : pdg_(0), p4_(0.,0.,0.,0.),mass_(0.) {};
  ParticleDescrShortRecord(int pdg, TLorentzVector p4): pdg_(pdg), p4_(p4),mass_(0.) {};
  ParticleDescrShortRecord(const ParticleDescrShortRecord &p) : pdg_( p.getPDG() ), p4_( p.getP4() ),mass_( p.getMass() ) {};

  virtual ~ParticleDescrShortRecord() {};

  int getPDG() const                                  {return pdg_;}
  double getMass() const                              {return mass_;}
  TLorentzVector getP4() const                        {return p4_;}

  void setPDG(int pdg)                                {pdg_ = pdg;}
  void setMass(double mass)                           {mass_ = mass;}
  void setP4(TLorentzVector v)                        {p4_ = v;}

  ParticleDescrShortRecord &operator=(const ParticleDescrShortRecord &p) {
    pdg_ = p.getPDG();
    p4_  = p.getP4();
    mass_  = p.getMass();
    
    return *this;
  };

  //void printToStream(ostream& stream);

 protected:
  int pdg_;
  double mass_;
  TLorentzVector p4_;

  ClassDef(ParticleDescrShortRecord, 1);
};

class ParticleDescrRecord : public ParticleDescrShortRecord {
 public:
  ParticleDescrRecord(): ParticleDescrShortRecord::ParticleDescrShortRecord(int(0), TLorentzVector(0.,0.,0.,0.)),pos_(0.,0.,0.,0.) {};
  ParticleDescrRecord(int pdg, TLorentzVector p4, TLorentzVector pos) : ParticleDescrShortRecord::ParticleDescrShortRecord(pdg, p4), pos_(pos) {};
  ParticleDescrRecord(const ParticleDescrRecord &p) : 
	ParticleDescrShortRecord::ParticleDescrShortRecord( p.getPDG(), p.getP4() ), pos_( p.getPosition() ) {};

  virtual ~ParticleDescrRecord() {};

  TLorentzVector getPosition() const                  {return pos_;}

  void setPosition(TLorentzVector v)                  {pos_ = v;}

  ParticleDescrRecord& operator=(const ParticleDescrRecord &p){
    pdg_ = p.getPDG();
    p4_  = p.getP4();
    mass_  = p.getMass();
    pos_ = p.getPosition();
    
    return *this;
  };

  // void printToStream(ostream& stream);

 private:
  TLorentzVector pos_;

  ClassDef(ParticleDescrRecord, 1);
};

class SDHit : public BaseEventRecord{
 public:
  SDHit() {name_ = "SDHit";}
  SDHit(const SDHit &hit);
  virtual ~SDHit() {};

  void setMuon(ParticleDescrShortRecord m) {muon_ = m;}
  ParticleDescrShortRecord getMuon() const {return muon_;}

  void setEdep(double e)                   {Edep_ = e;}
  double getEdep() const                   {return Edep_;}

  void setP4(TLorentzVector mom)           {p4 = mom;}
  TLorentzVector getP4() const         	   {return p4;}

  void setKinEnergy(double e)              {kinEnergy = e;}
  double getKinEnergy() const              {return kinEnergy;}

  int getNSteps() const                    {return nSteps_;}
  void setNSteps(int n)                    {nSteps_ = n;}

  void setPDG(int pdg)			   {PDG = pdg;};
  int getPDG() const			   {return PDG;};

  void setTrackID(int tID)		   {trackID = tID;};
  int getTrackID() const		   {return trackID;};

  void setParentID(int pID)		   {parentID = pID;};
  int getParentID() const		   {return parentID;};

  void setTrackLeftVolume(int tlv)	   {trackLeftVolume = tlv;};
  int getTrackLeftVolume() const	   {return trackLeftVolume;};

  void printToStream(ostream& stream);

protected:
  ParticleDescrShortRecord muon_;

  int nSteps_,PDG,trackID,parentID;
  double Edep_,kinEnergy;
  TLorentzVector p4;
  int trackLeftVolume;

  ClassDef(SDHit, 1);
};


class SimulData  : public namedRecord {
 public:
  SimulData() {name_ = "SimulData";}
  virtual ~SimulData() {};

  int getEventID()			const	{return eventID;};
  void setEventID(int ev) 			{eventID = ev;};

  std::vector<SDHit> getSDHits() 	       const 	{return SD_hits_;}
  void setSDHits(std::vector<SDHit> h)  		{SD_hits_ =h;}

  void clearSDHits()				{std::vector<SDHit>().swap(SD_hits_);SD_hits_.resize(0);}

  //void printToStream(ostream& stream);

 private:
  int 			eventID;
  std::vector<SDHit>  	SD_hits_;

  ClassDef(SimulData, 1);
};