#ifndef PHOTONS_Photon_Splitter_Sudakov_H
#define PHOTONS_Photon_Splitter_Sudakov_H

#include "ATOOLS/Math/Vector.H"
#include "ATOOLS/Phys/Blob.H"
#include "PHOTONS++/PhotonSplitter/Splitting_Functions.H"
#include "PHOTONS++/PhotonSplitter/Kinematics_Base.H"
#include <cstddef>
#include "ATOOLS/Math/Histogram.H"
#include "ATOOLS/Math/Histogram_2D.H"

namespace PHOTONS {

  class Sudakov {
  private:
    Kinematics_FF * p_kinematics;
    Kinematics_FI * p_FIkinematics;
    SF_Vector       m_splitters;
    Spec_Vector     m_spectators;

    std::vector<size_t> m_splitterIds;
    int                 m_NInP;

    int m_mode;
    int m_virtualityOrdering;
    int m_spectatorScheme;
    bool m_debug_initProbabilistic;
    double m_masscutoff;

    double m_t0;
    double m_t;

    // flavour-dependent enhancements
    std::map<kf_code,double> m_enhancefac;

    // for storing splittings
    Part_List m_remainingphotons;
    Particle_Vector m_addedparticles;

    bool m_addedanything;

    static std::string          s_histo_base_name;
    static ATOOLS::Histogram    s_histo_dipole;
    static ATOOLS::Histogram_2D s_histo_tdR;

    void RegisterDefaults();

  public:
    Sudakov();
    Sudakov(int mode);
    ~Sudakov();

    inline void SetNInParticles(int n) { m_NInP = n; }
    void AddSplitter(ATOOLS::Particle *softphoton, const size_t&);
    void AddChargedParticle(ATOOLS::Particle* p, const size_t& id);
    inline Spec_Vector GetSpectators() { return m_spectators; }
    bool ClearAll();

    void SetCutoff();
    Spectator* DefineInitialConditions(double &t,ATOOLS::Vec4D pphoton);

    bool Run(ATOOLS::Blob *blob);
    bool Generate(ATOOLS::Blob *blob);

    std::string Info() const { return std::string(""); }
    
    inline Part_List GetRemainingSoftPhotons() { return m_remainingphotons; }
    inline Particle_Vector GetAddedParticles() { return m_addedparticles; }
    inline bool AddedAnything() { return m_addedanything; }
  };

  /*!
    \file Sudakov.H
    \brief Contains the class PHOTONS::Sudakov
  */

  /*! 
    \class Sudakov
    \brief Implements the veto algorithm for a 1-step parton shower to split soft photons.
  */
  /////////////////////////////////////////////////////////////////////////////////////////
  // Description of member variables for Photon_Splitter
  /////////////////////////////////////////////////////////////////////////////////////////
  /*!
    \var Sudakov::m_mode
    \brief encodes which splittings to include. Settings are additive. 
    1 = electrons, 2 = muons, 4 = taus, 8 = hadrons up to mass cutoff.
  */
  /*!
    \var Sudakov::m_virtualityOrdering
    \brief stores the ordering scheme to be used. 0 is transverse momentum ordering, 
    1 is virtuality ordering and 2 is mixed (default).
  */
  /*!
    \var Sudakov::m_spectatorScheme
    \brief stores the spectator scheme to be used: 
    0 = all final-state charged particles that exist prior to this module being called (default), 
    1 = only the final-state charged particle that the soft photon is calculated to be emitted off.
  */
  /*!
    \var Sudakov::m_debug_initProbabilistic
    \brief if off, chooses starting scale by winner-takes all. Default is on.
  */
  /*!
    \var Sudakov::m_masscutoff
    \brief the mass of the heaviest hadron which can be produced by photon splittings. Note only 
    fermion and scalar splitting functions are currently implemented.
  */
  /*!
    \var Sudakov::m_t0
    \brief the IR cutoff of the algorithm. Defaults to 4m^2 where m is the mass of the lightest 
    particle which can be produced in photon splittings. 
  */
  /*!
    \var Sudakov::m_remainingphotons
    \brief stores the photons which have not (yet) split.
  */
  /*!
    \var Sudakov::m_addedparticles
    \brief stores the particles which are to be added to the blob. 
  */
  /*!
    \var Sudakov::m_addedanything 
    \brief flags whether anything has changed so the blob can be updated. 
  */
  /*!
    \var Sudakov::m_splitterIds
    \brief keeps track of the splitter photon associated with each splitting function.
  */
  /*!
    \var Sudakov::m_NInP
    \brief the number of incoming particles in the blob. Used to classify particles as 
    incoming or outgoing by their ID without referring to the blob. 
  */

  /////////////////////////////////////////////////////////////////////////////////////////
  // Description of member methods for Photon_Splitter
  /////////////////////////////////////////////////////////////////////////////////////////
  /*!
    \fn void Sudakov::AddSplitter(ATOOLS::Particle* photon, const size_t& id)
    \brief Creates the splitting functions for this photon.
  */
  /*!
    \fn void Sudakov::AddChargedParticle(ATOOLS::Particle* p, const size_t& id)
    \brief Assesses whether the charged particle can be a spectator and adds it if so.
  */
  /*!
    \fn bool Sudakov::ClearAll()
    \brief resets the Sudakov for the next event.
  */
  /*!
    \fn void Sudakov::SetCutoff()
    \brief sets the IR cutoff for the algorithm as described above. 
  */
  /*!
    \fn Spectator* Sudakov::DefineInitialConditions(double &t, Vec4D pphoton)
    \brief Reconstructs the emission history of the given photon and returns 
    the recontructed spectator and starting scale. 
  */
  /*!
    \fn bool Sudakov::Run(ATOOLS::Blob *)
    \brief Runs the algorithm until the scale is below the cutoff. 
  */
  /*!
    \fn bool Sudakov::Generate (ATOOLS::Blob *)
    \brief Generates trial emissions, lets the splitting functions compete and corrects 
    the splitting probability with a veto. 
  */
}

#endif