#ifndef HMETAMATCH_H
#define HMETAMATCH_H
#include "hreconstructor.h"
#include "TString.h"
#include "TObject.h"

#define RICH_TAB_SIZE 3

class HMetaMatch:public TObject {
private:
   Int_t   trkCandInd;         // index of HTrkCand object
   Short_t showerHitInd;       // index of HShowerHit(Tof) object
   Short_t tofHitInd;          // index of HTofHit or HTofCluster object
   Short_t nCandForMeta;       // number of MetaMatch obj. for the same HTrkCand
                               // >0 for first MetaMatch obj. in this chain
                               // <0 one of the next MetaMatch obj.
   Int_t   nextCandForMeta;    // index of next MetaMatch obj. for the same HTrkCand
                               // = -1 no next object
   Int_t   firstCandForMeta;   // index of the first MetaMatch obj. for the same HTrkCand in this chain
   Float_t qualityTOF;         // MDC TOF matching quality
   Float_t qualitySHOWER;      // MDC SHOWER matching quality
   Float_t dxMeta;             // Deviation in X-coordinate in META between hit and segment
   Float_t dyMeta;             // Deviation in X-coordinate in META between hit and segment

   Int_t   splineInd;          // index of HSplineTrack object
Int_t rtInd;       // index of HRtMetaTrack object
Int_t kickInd;     // index of HKickTrackB in catKickTrackB
Int_t kick123Ind;  // index of HKickTrack123B in catKickTrack123B
   Int_t   rungeKuttaInd;      // index of HRKTrackB in catRKTrackB
   Int_t   kalmanFilterInd;    // index of HK??? in catK???
   Char_t  sector;             // sector number

   Short_t nRichId;            // number of matched rings in aRichIndTable[]
   Short_t nRichIPUId;         // number of matched rings in aRichIPUIndTable[]
   Int_t   aRichIndTable[RICH_TAB_SIZE];    // arr.of indexes of HRichHit objects
   Int_t   aRichIPUIndTable[RICH_TAB_SIZE]; // arr.of indexes of HRichHitIPU objects
                                            // arrais are sorted by matching quality

   Char_t  flag;               // User flags bit array (8 flags, one bit / flag)
                               // First bit for spline track
                               // Second bit for Rt track
                               // Third bit for kick track
                               // Fourth bit for kick123 track
                               // Sixth bit reserved for rungeKutta track (but not yet implemented)
                               // If flag for corresponding track =1,
                               // this track is accepted

   Char_t  tofClusterSize;     // tofClusterSize / tofHitInd
                               //   ==0          / HTofHit index in catTofHit
                               //   >=1          / HTofCluster index in catTofCluster
                               //   ==-1         / HTofHit index; hit belong TofCluster
                               //                /   with size >2
   Int_t   indMMForTofClst;    // index of MetaMatch obj. with tofTofClusterSize>1
   Int_t   nextMMForTofHit;    // index of MetaMatch obj. with next stripe(TofHit) from TofCluster

   Short_t numMMForSameMeta;   // number of MetaMatch obj. for the same meta hit
   Int_t   nextMMForSameMeta;  // index of the next MetaMatch obj. for the same meta hit
   Int_t   firstMMForSameMeta; // index of the first MetaMatch obj. for the same meta hit in this chain

   Float_t xSegCr;             // x,y (z=0) - cross point of MdcSeg with meta
   Float_t ySegCr;             // detector (tof or shower) in module coor.sys.
                               // of this meta hit

public:
   HMetaMatch();
   ~HMetaMatch(){}
   HMetaMatch(Short_t sec, Int_t tkInd, Int_t ind);
   HMetaMatch(HMetaMatch* fMetaMatch, Int_t ind);
   HMetaMatch& operator=(const HMetaMatch& met);
   void setTrkCandInd(Int_t tr)                {trkCandInd=tr;}
 void setMetaHitInd(Short_t s, Short_t t)    {showerHitInd=s; tofHitInd=t;} //???? KickTrack use only!
   void setShowerHitInd(Short_t s)             {showerHitInd=s;}
   void setTofHitInd(Short_t t)                {tofHitInd=t;}
   void setTofClusterSize(Char_t cs)           {tofClusterSize=cs;}
   void setNumMMForSameTrCnd(Short_t nm)       {nCandForMeta=nm;}
   void setNextMMForSameTrCnd(Int_t nxm)       {nextCandForMeta=nxm;}
   void setFirstMMForSameTrCnd(Int_t fm)       {firstCandForMeta=fm;}
   void setQualityTOF(Float_t qt)              {qualityTOF=qt;}
   void setQualitySHOWER(Float_t qs)           {qualitySHOWER=qs;}
   void setdxMeta(Float_t dxm)                 {dxMeta=dxm;}
   void setdyMeta(Float_t dym)                 {dyMeta=dym;}
   void setMdcSegCross(Float_t x, Float_t y)   {xSegCr=x; ySegCr=y;}

   void setSplineInd(Int_t splind);
void setRtInd(Int_t rtind);        //?????????
void setKickInd(Int_t kicktr);     //?????????
void setKick123Ind(Int_t kicktr);  //?????????
   void setRungeKuttaInd(Int_t rktr);
   void setKalmanFilterInd(Int_t kftr);

   void setSector(Char_t sec)                  {sector=sec;}
   void setNCandForRich(Short_t nrich)         {nRichId=nrich;}
   void setNCandForIPU(Short_t nrich)          {nRichIPUId=nrich;}
   void setARichInd(Short_t id, Short_t rind)  {
     if(id>=0&& id<RICH_TAB_SIZE) aRichIndTable[id] = rind;}
   void setARichIPUInd(Short_t id, Short_t rind) {
     if(id>=0&& id<RICH_TAB_SIZE) aRichIPUIndTable[id] = rind;}
   void setIndMMForTofClst(Int_t ind)          {indMMForTofClst=ind;}
   void setNextMMForTofHit(Int_t ind)          {nextMMForTofHit=ind;}
   void setNumMMForSameMeta(Short_t n)         {numMMForSameMeta=n;}
   void setNextMMForSameMeta(Int_t ind)        {nextMMForSameMeta=ind;}
   void setFirstMMForSameMeta(Int_t ind)       {firstMMForSameMeta=ind;}

   Char_t  getSector(void) const               {return sector;}
   Int_t   getTrkCandInd(void) const           {return trkCandInd;}
   Short_t getNumMMForSameTrCnd(void) const    {return nCandForMeta;}
   Int_t   getFirstMMForSameTrCnd(void) const  {return firstCandForMeta;}
   Int_t   getNextMMForSameTrCnd(void) const   {return nextCandForMeta;}

   Float_t getQualityTOF(void) const           {return qualityTOF;}
   Float_t getQualitySHOWER(void) const        {return qualitySHOWER;}
   Float_t getdxMeta(void) const               {return dxMeta;}
   Float_t getdyMeta(void) const               {return dyMeta;}

   Int_t   getSplineInd(void) const            {return splineInd;}
Int_t getRtInd(void) const {return rtInd;}
Int_t getKickInd(void) const {return kickInd;}
Int_t getKick123Ind(void) const {return kick123Ind;}
   Int_t   getRungeKuttaInd(void) const        {return rungeKuttaInd;}
   Int_t   getKalmanFilterInd(void) const      {return kalmanFilterInd;}
 Short_t getMetaHitInd(void) const           {return getSystem()==1 ? tofHitInd:showerHitInd;} //???
 Int_t   getSystem(void) const               {return tofHitInd>-1 ? 1 : (showerHitInd>-1 ? 0:-1); } //???
   Short_t getShowerHitInd(void) const         {return showerHitInd;}
   Short_t getTofHitInd(void) const            {return tofHitInd;}
   Char_t  getTofClusterSize(void) const       {return tofClusterSize;}
   Float_t getXSegCross(void) const            {return xSegCr;}
   Float_t getYSegCross(void) const            {return ySegCr;}

   Short_t getNCandForRich(void) const         {return nRichId;}
   Short_t getNCandForIPU(void) const          {return nRichIPUId;}
   Short_t getARichInd(const Short_t id) const    {return id<RICH_TAB_SIZE ? aRichIndTable[id]:-1;}
   Short_t getARichIPUInd(const Short_t id) const {return id<RICH_TAB_SIZE ? aRichIPUIndTable[id]:-1;}

   Int_t   getIndMMForTofClst(void) const      {return indMMForTofClst;}
   Int_t   getNextMMForTofHit(void) const      {return nextMMForTofHit;}
   Short_t getNumMMForSameMeta(void) const     {return numMMForSameMeta;}
   Int_t   getNextMMForSameMeta(void) const    {return nextMMForSameMeta;}
   Int_t   getFirstMMForSameMeta(void) const   {return firstMMForSameMeta;}

   inline void incrNumMMForSameTrkCnd(void);
   void    setSplineAccept(void)               {flag |=  1;}  // First bit for spline track
void    setRtAccept(void)          {flag |=  2;}  // Second bit for Rt track       //???????
void    setKickAccept(void)        {flag |=  4;}  // Third bit for kick track      //???????
void    setKick123Accept(void)     {flag |=  8;}  // Fourth bit for kick123 track  //???????
   void    setRungeKuttaAccept(void)           {flag |= 16;}  // Fifth bit for kick123 track
   void    setKalmanFilterAccept(void)         {flag |= 32;}  // Fifth bit for kick123 track

   void    unsetSplineAccept(void)             {flag &=  ~1;}
void    unsetRtAccept(void)        {flag &=  ~2;}      //???????
void    unsetKickAccept(void)      {flag &=  ~4;}      //???????
void    unsetKick123Accept(void)   {flag &=  ~8;}      //???????
   void    unsetRungeKuttaAccept(void)         {flag &= ~16;}
   void    unsetKalmanFilterAccept(void)       {flag &= ~32;}

   Bool_t  isSplineAccepted(void)   const      {return (flag&1) != 0;}
Bool_t  isRtAccepted(void)       const  {return (flag&2) != 0;}      //???????
Bool_t  isKickAccepted(void)     const  {return (flag&4) != 0;}      //???????
Bool_t  isKick123Accepted(void)  const  {return (flag&8) != 0;}      //???????
   Bool_t  isRungeKuttaAccepted(void) const    {return (flag&16) != 0;}
   Bool_t  isKalmanFilterAccepted(void) const  {return (flag&32) != 0;}

   void    print(void);
   
private:   
   void    setDefForRest(void);

   ClassDef(HMetaMatch,1)
};

void HMetaMatch::incrNumMMForSameTrkCnd(void) {
  if(nCandForMeta<=0) nCandForMeta = 1;
  else                nCandForMeta++;
}

#endif