#ifndef TV0_HH
#define TV0_HH

#include <iostream>

#include "Stntuple/Stntuple/obj/TStnTrack.hh"
#include "Stntuple/Stntuple/obj/TObspBlock.hh"
#include "Stntuple/Stntuple/obj/TObspParticle.hh"
#include "Stntuple/Stntuple/obj/TObsvVertex.hh"
#include "Stntuple/Stntuple/geom/TLine3D.hh"

#include "TObject.h"
#include "TVector3.h"
#include "TLorentzVector.h"

using namespace std;

class TV0 : public TObject
{
public:
  TV0(Int_t, TObspBlock * = NULL);
  ~TV0() {}

  // Setters
  void SetMatching(Int_t   m = 0)                     { fMatching = m; }
  void SetObsParticle(TObspParticle *p = NULL)        { fObsFlag ? fObsParticle = p : fObsParticle = NULL; }
  
  void SetBeam(Double_t x, Double_t y)                { fBeamX = x; fBeamY = y; }

  void SetTrackRec(Int_t,    TStnTrack *,     Int_t);
  void SetHelixFit(Int_t,    Double_t [5],    Int_t);
  void SetHelixFitCov(Int_t, Double_t [3][3]);
  void Set4PFit(Int_t,       TLorentzVector);

  void SetPrimaryVertexPosition(TVector3    p)        { fPrimaryVertexPosition    = p; }
  void SetPrimaryVertexCov(float [9]);
  void SetDecayVertexPosition(TVector3      d)        { fDecayVertexPosition      = d; }
  void SetDecayVertexPositionError(TVector3 d)        { fDecayVertexPositionError = d; }
  
  void SetChiSqr(Double_t  c)                         { fObsFlag ? fChiSqr  = -1. : fChiSqr  = c; }
  void SetNdof(Double_t    n)                         { fObsFlag ? fNdof    = -1. : fNdof    = n; }
  void SetProb(Double_t    p)                         { fObsFlag ? fProb    = -1. : fProb    = p; }
  void SetMassErr(Double_t m)                         { fObsFlag ? fMassErr = -1. : fMassErr = m; }

  void Go();

  void SetIsAGoodV0(Bool_t      s = true)             { fIsAGoodV0       = s; }
  void SetRejectionReason(Int_t r = 0)                { fRejectionReason = r; }
  
  // Getters
  const char     *GetVersion()                 { return kClassVersion; }

  Bool_t         GetObsFlag()                  { return fObsFlag; }
  Int_t          GetMatching()                 { return fMatching; }
  TObspParticle  *GetObsParticle()             { return fObsParticle; }
  Int_t          GetV0Type()                   { return fV0Type; }

  TStnTrack      *GetTrackRec(Int_t);
  Int_t          GetTrackRecNum(Int_t);
  Int_t          GetTrackRecType(Int_t);
  Double_t       *GetHelixFit(Int_t);
  Double_t       *GetHelixFitCov(Int_t);
  Int_t          GetHelixFitType(Int_t);
  TLorentzVector *Get4PFit(Int_t);

  TVector3       GetPrimaryVertexPosition()    { return fPrimaryVertexPosition; }
  Double_t       *GetPrimaryVertexCov()        { return fPrimaryVertexCov[0]; }
  TVector3       GetDecayVertexPosition()      { return fDecayVertexPosition; }
  TVector3       GetDecayVertexPositionError() { return fDecayVertexPositionError; }

  Double_t       GetChiSqr()                   { return fChiSqr; }
  Double_t       GetNdof()                     { return fNdof; }
  Double_t       GetProb()                     { return fProb; }
  Double_t       GetMass()                     { return fMass; }
  Double_t       GetMassErr()                  { return fMassErr; }
  Double_t       GetExpMass(Int_t);
  Double_t       GetLxy()                      { return fLxy; }
  Double_t       GetZ0()                       { return fZ0; }
  Double_t       GetDeltaZ()                   { return fDeltaZ; }
  Double_t       GetPt()                       { return fPt; }
  Double_t       GetEta()                      { return fEta; }
  Double_t       GetPhi0()                     { return fPhi0; }
  Double_t       GetD0()                       { return fD0; }
  Double_t       GetTau()                      { return fTau; }
  Double_t       GetCTau()                     { return fCTau; }
  Double_t       GetMassPull()                 { return fMassPull; }

  Bool_t         IsAGoodV0()                   { return fIsAGoodV0; }
  Int_t          GetRejectionReason()          { return fRejectionReason; }
  
  void           Print(const Option_t *) const { Print(); }
  void           Print() const;
  
private:
  const char     *kClassVersion;

  const Double_t kPi;
  const Double_t k2Pi;
  const Double_t kc;
  const Double_t kMassPi;
  const Double_t kMassK0;
  const Double_t kMassP;
  const Double_t kMassL0;

  Bool_t         fObsFlag;
  TObspBlock     *fObsBlock;
  Int_t          fMatching;
  TObspParticle  *fObsParticle;
  Int_t          fV0Type;

  Double_t       fChiSqr;
  Double_t       fNdof;
  Double_t       fProb;
  Double_t       fMass;
  Double_t       fMassErr;
  Double_t       fLxy;
  Double_t       fZ0;
  Double_t       fDeltaZ;
  Double_t       fPt;
  Double_t       fEta;
  Double_t       fPhi0;
  Double_t       fD0;
  Double_t       fTau;
  Double_t       fCTau;
  Double_t       fMassPull;

  Double_t       fBeamX;
  Double_t       fBeamY;

  TStnTrack      *fTrackRec[2];
  Int_t          fTrackRecType[2];
  Double_t       fHelixFit[2][5];
  Double_t       fHelixFitCov[2][3][3];
  Int_t          fHelixFitType[2];
  TLorentzVector f4PFit[2];

  TVector3       fPrimaryVertexPosition;
  Double_t       fPrimaryVertexCov[3][3];
  TVector3       fDecayVertexPosition;
  TVector3       fDecayVertexPositionError;

  Bool_t         fIsAGoodV0;
  Int_t          fRejectionReason;
  
  ClassDef(TV0,0)
};

#endif