#ifndef HKalTrackSite_h
#define HKalTrackSite_h

// from ROOT
#include "TClonesArray.h"
#include "TMatrixD.h"
class     TVector3;
#include "TVectorD.h"

// from kalman
#include "hkaldef.h"
#include "hkalmdchit.h"
class     HKalMdcMeasLayer;
#include "hkaltrackstate.h"

using namespace Kalman;

#include <iostream>
using namespace std;
#include <cstdlib>

class HKalTrackSite : public TObject {

private:
    Double_t         energyLoss;   //! Energy loss from the first site to this site in MeV/particle charge in elementary charges. Sign depends on propagation direction. This number is positive for forward and negative for backward iteraton.
    TObjArray       *hits;         //! Stores all competing measurement hits->
    HKalTrackState **trackStates;  //! array with the track parameters for each track state

private:

    virtual HKalMdcHit* getHit  (Int_t idx=0);

    virtual void transformHit   (const TRotation *transMat);

    virtual void transformStates(const TRotation *transMat);

public:

    HKalTrackSite(Int_t measDim, Int_t stateDim);

    //HKalTrackSite(HKalMdcHit *hit, Int_t stateDim, Int_t nComp=1);

    virtual ~HKalTrackSite();

    virtual void addHit               (HKalMdcHit *newhit);

    virtual void calcMeasVecFromState (TVectorD &measVec, Kalman::kalFilterTypes stateType) const;

    virtual void clearHits            ();

    virtual void getPosAndDirFromState(TVector3 &pos, TVector3 &dir, Kalman::kalFilterTypes stateType) const;

    virtual void print                (const Option_t *opt="") const;

    virtual void sortHits             ();

    virtual void transform            (const TRotation *transMat);

    virtual Double_t          getEnergyLoss        () const                            { return energyLoss; }

    virtual HKalMdcHit const& getHit               (Int_t idx=0) const;

    virtual Double_t          getHitChi2           (Int_t idx=0) const                 { return getHit(idx).getChi2(); }

    virtual TVectorD   const& getHitVec            (Int_t idx=0) const                 { return getHit(idx).getHitVec(); }

    virtual void              getHitVec3           (TVector3 &hit3, Int_t idx=0) const { getHit(idx).getHitVec3(hit3); }

    virtual Double_t          getHitsTotalWeight   ();

    virtual Double_t          getHitWeight         (Int_t idx=0) const                 { return getHit(idx).getWeight(); }

    virtual TMatrixD   const& getErrMat            (Int_t idx=0) const                 { return getHit(idx).getErrMat(); }

    virtual TVectorD   const& getErrVec            (Int_t idx=0) const                 { return getHit(idx).getErrVec(); }

    virtual void              getErrVec3           (TVector3 &err3, Int_t idx=0) const { getHit(idx).getErrVec3(err3); }

    virtual HKalTrackState   const& getState       (Kalman::kalFilterTypes stateType) const { return *trackStates[stateType]; }

    virtual Int_t             getMeasDim           () const                            { return getHit().getDimension(); }

    virtual HKalMdcMeasLayer const& getMeasLayer   () const                            { return getHit().getMeasLayer(); }

    virtual Int_t             getNcompetitors      () const                            { return hits->GetEntries(); }

    virtual Int_t             getStateDim          () const                            { return trackStates[kPredicted]->getStateDim(); }

    virtual Double_t          getStateParam        (Kalman::kalFilterTypes stateType, Kalman::kalStateIdx par) const { return trackStates[stateType]->getStateParam(par); }

    virtual TVectorD   const& getStateVec          (Kalman::kalFilterTypes stateType) const { return trackStates[stateType]->getStateVec(); }

    virtual TMatrixD   const& getStateCovMat       (Kalman::kalFilterTypes stateType) const { return trackStates[stateType]->getCovMat(); }

    virtual TMatrixD   const& getStatePropMat      (Kalman::kalFilterTypes stateType) const { return trackStates[kFiltered]->getPropMat(); }

    virtual TMatrixD   const& getStateProjMat      (Kalman::kalFilterTypes stateType) const { return trackStates[kFiltered]->getProjMat(); }

    virtual TMatrixD   const& getStateProcNoiseMat (Kalman::kalFilterTypes stateType) const { return trackStates[kFiltered]->getProcNoiseMat(); }

    virtual void      setEnergyLoss       (Double_t eloss)                                           { energyLoss = eloss; }

    virtual void      setHitChi2          (Double_t chi2, Int_t idx=0)                               { getHit(idx)->setChi2(chi2); }

    virtual void      setHitWeight        (Double_t weight, Int_t idx=0)                             { getHit(idx)->setWeight(weight); }

    virtual void      setStateCovMat      (Kalman::kalFilterTypes stateType, const TMatrixD &fCov)   { trackStates[stateType]->setCovMat(fCov); }

    virtual void      setStatePropMat     (Kalman::kalFilterTypes stateType, const TMatrixD &fProp)  { trackStates[stateType]->setPropMat(fProp); }

    virtual void      setStateProjMat     (Kalman::kalFilterTypes stateType, const TMatrixD &fProj)  { trackStates[stateType]->setProjMat(fProj); }

    virtual void      setStateProcNoiseMat(Kalman::kalFilterTypes stateType, const TMatrixD &fProc)  { trackStates[stateType]->setProcNoiseMat(fProc); }

    virtual void      setStateVec         (Kalman::kalFilterTypes stateType, const TVectorD &sv)     { trackStates[stateType]->setStateVec(sv); }

    ClassDef(HKalTrackSite, 0)
};

#endif // HKalTrackSite_h