#ifndef ALIRSNDAUGHTERDEF_H
#define ALIRSNDAUGHTERDEF_H

//
//  Definition for a single candidate daughter.
//  They can be chosen among the following possibilities:
//
//  -- particle species, chosen in the enum AliRsnDaughter::ESpecies;
//     this option does two things:
//     -- when possible (needs MC) and required, allow to check is a daughter
//        is of the defined species (e.g.: for selecting true daughters of a resonance)
//     -- defines the mass to be assigned to this object, for any purpose
//        (e.g.: to compute its 4-momentum to be used for a resonance mass)
//
//  -- track charge, which can be '+', '-', '0',
//     -- any other char leaves this undefined (use only in daughter monitor loops)
//     -- when doing resonance analysis, or when RSN Input handler needs to be used,
//        this must always be defined
//
//  -- object type (track/V0/cascade)
//     -- could be needed to select tracks when particle species is not specified
//     -- works only in single daughter loops
//

#include "AliRsnDaughter.h"

class AliRsnDaughterDef : public TObject {
public:

   AliRsnDaughterDef();
   AliRsnDaughterDef(EPARTYPE type, Char_t charge = 0);
   AliRsnDaughterDef(AliRsnDaughter::ESpecies type, Char_t charge = 0);
   AliRsnDaughterDef(AliRsnDaughter::ERefType refType, Char_t charge = 0);
   AliRsnDaughterDef(const AliRsnDaughterDef &copy);
   AliRsnDaughterDef &operator= (const AliRsnDaughterDef &copy);
   virtual ~AliRsnDaughterDef() { }

   AliRsnDaughter::ESpecies GetPID()          const {return fPID;}
   Double_t                 GetMass()         const {return fMass;}
   Char_t                   GetChargeC()      const {return fCharge;}
   Short_t                  GetChargeS()      const {if (fCharge == '+') return 1; else if (fCharge == '-') return -1; else return 0;}
   AliRsnDaughter::ERefType GetRefType()      const {return fRefType;}
   virtual const char      *GetName()         const {return Form("%s%c", AliRsnDaughter::SpeciesName(fPID), fCharge);}
   Bool_t                   IsChargeDefined() const {return (fCharge == '+' || fCharge == '-' || fCharge == '0');}

   void SetPID(AliRsnDaughter::ESpecies pid)      {fPID = pid; fRefType = AliRsnDaughter::RefType(pid); fMass = AliRsnDaughter::SpeciesMass(pid);}
   void SetCharge(Char_t charge)                  {fCharge = charge;}
   void SetRefType(AliRsnDaughter::ERefType type) {fRefType = type;}

   Bool_t MatchesPID(AliRsnDaughter *daughter);
   Bool_t MatchesCharge(AliRsnDaughter *daughter)  const;
   Bool_t MatchesRefType(AliRsnDaughter *daughter) const;
   Bool_t MatchesPDG(Int_t pdgCode)                  {return (AliRsnDaughter::SpeciesPDG(fPID) == pdgCode);}
   Bool_t MatchesChargeS(Short_t charge) const       {return (GetChargeS() == charge);}
   Bool_t MatchesChargeC(Char_t charge)  const       {return (GetChargeC() == charge);}

private:

   AliRsnDaughter::ESpecies  fPID;      // PID of particles
   Double_t                  fMass;     // mass of particles (subordinate to fPID)
   Char_t                    fCharge;   // charge of particles
   AliRsnDaughter::ERefType  fRefType;  // object reference type (track/V0/cascade)

   // ROOT dictionary
   ClassDef(AliRsnDaughterDef, 1)
};

//__________________________________________________________________________________________________
inline Bool_t AliRsnDaughterDef::MatchesPID(AliRsnDaughter *daughter)
{
//
// Checks if the passed daughter true particle type
// matches the species defined in fPID data member,
// by comparing the corresponding PDG codes of both in absolute value.
// Returns kTRUE when the two codes match, and kFALSE when:
// -- PDG codes don't match
// -- fPID is not set to a well-defined species (AliRsnDaughter::kUnknown)
// -- passed daughter has not MC information
//
   if (fPID == AliRsnDaughter::kUnknown) {
      AliError("This DaughterDef has undefined species: cannot check PDG matching with passed arg");
      return kFALSE;
   } else if (!daughter->GetRefMC()) {
      AliError("The passed argument has NULL MC pointer: cannot check PDG matching with this DaughterDef");
      return kFALSE;
   }

   return MatchesPDG(daughter->GetPDGAbs());
}

//__________________________________________________________________________________________________
inline Bool_t AliRsnDaughterDef::MatchesCharge(AliRsnDaughter *daughter) const
{
//
// Checks if the passed daughter charge matches that defined in fCharge data member.
// If fCharge is not initialized to '+', '-' or '0', that is interpreted as if the user
// does not want to select in charge, and then the function returns always kTRUE.
//

   switch (fCharge) {
      case '+': return daughter->IsPos();
      case '-': return daughter->IsNeg();
      case '0': return daughter->IsNeutral();
      default : return kTRUE;
   }
}

//__________________________________________________________________________________________________
inline Bool_t AliRsnDaughterDef::MatchesRefType(AliRsnDaughter *daughter) const
{
//
// Checks that the daughter object type matches that defined in fRefType data member.
// If fRefType is initialized to AliRsnDaughter::kNoType, that is interpreted as if the user
// does not want to select in type and then the function returns always kTRUE.
//

   AliRsnDaughter::ERefType type = daughter->RefType();

   if (fRefType != AliRsnDaughter::kNoType)
      return (type == fRefType);
   else
      return kTRUE;
}

#endif