#ifndef KFParticleFinder_h
#define KFParticleFinder_h

#include "KFParticle.h"
#include "KFParticleSIMD.h"
#include "KFPTrack.h"

#include <vector>

#ifdef NonhomogeniousField
class L1FieldRegion;
#endif
class KFParticleSIMD;

class KFParticleFinder
{
 public:

  KFParticleFinder();
  ~KFParticleFinder() {};

  /// Find particles with 2-body decay channel from input tracks vRTracks with primary vertex PrimVtx:
  /// 1. K0s->pi+ pi-
  /// 2. Lambda->p pi-
  /// All particles are put into the Particles array. 3 cuts for each particle are required.
  /// First index in the cuts array sets a particle number (see table above), second index - a cut number:
  /// cut[0][0] - chi to a primary vertex of a track (sqare root from a normalized on a total error of 
  ///             the track and the vertex distance between the track and the primary vertex), only
  ///             element cut[0][0] is used to select tracks, all other elements cut[*][0] are not used;
  /// cut[*][1] - chi2/ndf of the reconstructed particle;
  /// cut[*][2] - z coordinate of the reconstructed particle.
  /// cut[*][3] - chi2/ndf of the reconstructed particle fitted to the PV;

    static void FindParticles(std::vector<KFPTrack>& vRTracks, std::vector<float>& ChiToPrimVtx,
#ifdef NonhomogeniousField
                                           std::vector<L1FieldRegion>& vField,
#endif
                               std::vector<KFParticle>& Particles,
                               KFParticleSIMD& PrimVtx, const std::vector<int>& vTrackPDG, const float cuts[2][3] = DefaultCuts);

    static void ExtrapolateToPV(std::vector<KFParticle>& vParticles, KFParticleSIMD& PrimVtx);
    static fvec GetChi2BetweenParticles(KFParticleSIMD &p1, KFParticleSIMD &p2);

    static void Find2DaughterDecay(std::vector<KFPTrack>& vTracks,
#ifdef NonhomogeniousField
                                   const std::vector<L1FieldRegion>& vField,
#endif
                                   std::vector<KFParticle>& Particles,
                                   const int DaughterNegPDG,
                                   const int DaughterPosPDG,
                                   const int MotherPDG,
                                   std::vector<short>& idNeg,
                                   std::vector<short>& idPos,
                                   KFParticleSIMD& PrimVtx,
                                   const float* cuts = 0,
                                   bool isPrimary = 0,
                                   std::vector<float>* vMotherTopoChi2Ndf = 0,
                                   const float* secCuts = 0,
                                   const float massMotherPDG = 0,
                                   const float massMotherPDGSigma = 0,
                                   std::vector<KFParticle>* vMotherPrim = 0,
                                   std::vector<KFParticle>* vMotherSec = 0);

    static void Find2DaughterDecay(std::vector<KFPTrack>& vTracks,
#ifdef NonhomogeniousField
                                   const std::vector<L1FieldRegion>& vField,
#endif
                                   std::vector<KFParticle>& Particles,
                                   const int DaughterNegPDG,
                                   const int DaughterPosPDG,
                                   const int MotherPDG,
                                   std::vector<short>& idNeg,
                                   std::vector<short>& idPos,
                                   KFParticleSIMD& PrimVtx,
                                   const float* cuts,
                                   bool isPrimary,
                                   const float PtCut,
                                   const float Chi2PrimCut = -100.f,
                                   std::vector<float>* ChiToPrimVtx = 0,
                                   const float* PCut = 0);

  static void FindTrackV0Decay(const int MotherPDG,
                               std::vector<KFParticle>& Particles,
                               std::vector<KFParticle>& vV0,
                               std::vector<KFPTrack>& vTracks,
#ifdef NonhomogeniousField
                               const std::vector<L1FieldRegion>& field,
#endif
                               const int DaughterPDG,
                               std::vector<short>& idTrack,
                               KFParticleSIMD& PrimVtx,
                               const float* cuts = 0,
                               bool isPrimary = 0,
                               std::vector<float>* ChiToPrimVtx = 0,
                               std::vector<KFParticle>* vHyperonPrim = 0,
                               float hyperonPrimMass = 0,
                               float hyperonPrimMassErr = 0,
                               std::vector<KFParticle>* vHyperonSec = 0);

  static void FindHyperons(int PDG,
                           KFParticleSIMD vDaughters[2],
                           std::vector<int>& daughterIds,
                           std::vector<KFParticle>& vLambdaSec,
                           std::vector<KFParticle>& vHyperon,
                           KFParticleSIMD& PrimVtx,
                           const float *cuts = 0,
                           int startIndex=0);

    static void FindDMesLambdac(std::vector<KFPTrack>& vTracks,
#ifdef NonhomogeniousField
                                const std::vector<L1FieldRegion>& vField,
#endif
                                std::vector<KFParticle>& Particles,
                                const int DaughterPDG[5], //pi, K_b, pi_b, K, p
                                const int MotherPDG[8],
                                std::vector<short>* idTrack[5], //pi, K_b, pi_b, K, p
                                KFParticleSIMD& PrimVtx,
                                const float cuts[8][8],
                                std::vector<float> ChiToPrimVtx);

    static void CombineTrackPart(std::vector<KFPTrack>& vTracks,
#ifdef NonhomogeniousField
                                 const std::vector<L1FieldRegion>& vField,
#endif
                                 std::vector<KFParticle>& Particles,
                                 KFParticle& part,
                                 const int DaughterPDG,
                                 const int MotherPDG,
                                 std::vector<short>& id,
                                 const float* cuts,
                                 const unsigned short startIndex = 0,
                                 const bool IsSamePart = 0);

  static void SelectParticleCandidates(std::vector<KFParticle>& Particles,
                                       std::vector<KFParticle>& vCandidates,
                                       KFParticleSIMD& PrimVtx,
                                       const float cuts[5]);

 private:

  static const float DefaultCuts[2][3];
};

#endif /* !KFParticleFinder_h */