#ifndef __JSUPPORT_JEVTWEIGHTFILESCANNERSET__
#define __JSUPPORT_JEVTWEIGHTFILESCANNERSET__

#include <set>
#include <vector>
#include <string>

#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"

#include "JLang/JException.hh"
#include "JLang/JPredicate.hh"
#include "JLang/JComparator.hh"

#include "JAAnet/JHead.hh"
#include "JAAnet/JEvtWeightToolkit.hh"
#include "JAAnet/JEvtWeightFactor.hh"
#include "JAAnet/JEvtWeightFactorHelper.hh"
#include "JAAnet/JEvtWeightFactorMultiParticle.hh"
#include "JAAnet/JFlux.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JEvtWeightFileScanner.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"


/**
 * \author bjung
 */

namespace JSUPPORT {

  using JLANG::JValueOutOfRange;

  using JAANET::JHead;
  
  using JAANET::JEvtWeightFactor;
  using JAANET::JEvtWeightFactorHelper;
  using JAANET::JEvtWeightFactorMultiParticle;
  
  using JAANET::JFlux;
  

  /**
   * Auxiliary class for organising Monte Carlo file scanners associated with event weighters.
   *
   * Note: The template class must be derived from JMultipleFileScanner<Evt>.
   */
  template<class JFileScanner_t = JMultipleFileScanner<Evt>,
	   class JComparator_t  = std::less<JHead> >
  struct JEvtWeightFileScannerSet :
    public std::vector< JEvtWeightFileScanner<JFileScanner_t> >
  {
    typedef JEvtWeightFileScannerSet<JFileScanner_t, JComparator_t>          filescannerset_type;
    typedef JEvtWeightFileScanner<JFileScanner_t>                            filescanner_type;

    typedef typename filescanner_type::input_type                            input_type;

    typedef typename std::vector<filescanner_type>::value_type               value_type;
    typedef typename std::vector<filescanner_type>::reference                reference;
    typedef typename std::vector<filescanner_type>::const_reference          const_reference;

    typedef typename std::vector<filescanner_type>::const_iterator           const_iterator;
    typedef typename std::vector<filescanner_type>::iterator                 iterator;
    typedef typename std::vector<filescanner_type>::const_reverse_iterator   const_reverse_iterator;
    typedef typename std::vector<filescanner_type>::reverse_iterator         reverse_iterator;
    

    
    /**
     * Default constructor.
     */
    JEvtWeightFileScannerSet()
    {}
    

    /**
     * Constructor.
     *
     * \param  input                       input files
     */
    JEvtWeightFileScannerSet(const input_type& input)
    {
      put(input);
    }
    
    
    /**
     * Put files
     *
     * \param  input                       input files
     * \return                             number of added files
     */
    size_t put(const input_type& input)
    {
      size_t n = 0;
      
      for (typename input_type::const_iterator i = input.begin(); i != input.end(); ++i) {
	n += size_t(this->put(*i));
      }

      return n;
    }
    
    
    /**
     * Put file
     *
     * \param  input                       input file
     * \return                             true if successfully added; else false.
     */
    bool put(const std::string& input)
    {
      using namespace std;
      using namespace JPP;
      
      const JHead& head = getHeader(input);

      iterator i = lower_bound(this->begin(),  this->end(),  head,
			       make_comparator(&JHead::getHeader, compare));

      if (i == this->end() || !i->getHeader().match(head)) {
	i = this->insert(i, value_type(getEventWeighter(head)));
      }

      return i->put(input);
    }


    /**
     * Get unique identifier for a file-scanner contained within this set of event-weighter-associated file-scanners.
     *
     * \param  p                           iterator to contained file-scanner
     * \return                             unique identifier of contained file-scanner
     */
    std::string getUniqueIdentifier(const_iterator p) const
    {
      using namespace std;
      using namespace JPP;

      static const char SEPARATOR = '.';

      string name  = p->getProgramName();
      int    index = 0;
      
      for (const_iterator i = this->cbegin(); i != this->cend() && i != p; ++i) {
	if (i->getProgramName() == name) {
	  ++index;
	}
      }
      
      return MAKE_STRING(name << SEPARATOR << index);
    }
    

    /**
     * Find file scanner compatible with a given header.
     *
     * \param  head                        header
     * \return                             file scanner
     */
    const_reference find(const JHead& head) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
	if (i->match(head)) {
	  return *i;
	}
      }

      THROW(JValueOutOfRange, "JEvtWeightFileScannerSet::get(): No corresponding scanner found for given header.");
    }
    

    /**
     * Set event-weighting factor for all MC-files corresponding to a given PDG code.
     *
     * The template argument corresponds to the desired class of event-weight factor.
     * This class must contain the method `getFactor(const Evt&)`.
     *
     * Note that the given event-weighting factor will only be assigned to those files\n
     * whose header exclusively lists the given PDG code as primary.
     *
     * \param  type                        PDG code
     * \param  factor                      event-weight factor
     * \return                             number of modified event weighters
     */
    template<class JEvtWeightFactor_t = JEvtWeightFactor>
    size_t setEvtWeightFactor(const int                 type,
			      const JEvtWeightFactor_t& factor)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;
	
      for (iterator i = this->begin(); i != this->end(); ++i) {
	n += (size_t) i->template setEvtWeightFactor<JEvtWeightFactor_t>(type, factor);
      }

      return n;
    }


    /**
     * Set event-weight factor of all MC-files corresponding to a given set of PDG codes.
     * 
     * The template argument corresponds to the desired class of event-weight factor.
     * This class must contain the method `getFactor(const Evt&)`.
     *
     * Note that the given event-weighting factor will only be assigned to those files\n
     * whose header lists < b>all< /b> of the specified PDG codes as primaries.
     *
     * \param  types                       set of PDG codes
     * \param  factor                      event-weight factor
     * \return                             number of modified event weighters
     */
    template<class JEvtWeightFactor_t = JEvtWeightFactor>
    size_t setEvtWeightFactor(const std::set<int>&      types,
			      const JEvtWeightFactor_t& factor)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;

      for (iterator i = this->begin(); i != this->end(); ++i) {
	n += (size_t) i->template setEvtWeightFactor<JEvtWeightFactor_t>(types, factor);
      }
      
      return n;
    }


    /**
     * Set event-weight factor of all MC-files corresponding to a given multi-particle flux.
     * 
     * The template argument corresponds to the desired class of event-weight factor.
     * This class must contain the method `getFactor(const Evt&)`.
     *
     * Note that the given event-weighting factors will only be assigned to those files\n
     * whose header lists < b>all< /b> of the PDG codes associated with the multi-particle event-weighting factor object as primaries.
     *
     * \param  multiParticleFactor        multi-particle event-weight factor
     * \return                            number of modified event weighters
     */
    template<class JEvtWeightFactor_t = JEvtWeightFactor>
    size_t setEvtWeightFactor(const JEvtWeightFactorMultiParticle<JEvtWeightFactor_t>& multiParticleFactor)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;
      
      for (iterator i = this->begin(); i != this->end(); ++i) {
	n += (size_t) i->template setEvtWeightFactor<JEvtWeightFactor_t>(multiParticleFactor);	
      }
      
      return n;
    }
    

    /**
     * Set flux function for all MC-files corresponding to a given PDG code.
     *
     * Note that only the given flux function will only be assigned to those files\n
     * whose header exclusively lists the given PDG code as primary.
     *
     * \param  type                        PDG code
     * \param  flux                        flux function
     * \return                             number of modified event weighters
     */
    size_t setFlux(const int    type,
		   const JFlux& flux)
    {
      return setEvtWeightFactor<JFlux>(type, flux);
    }


    /**
     * Set flux function of all MC-files corresponding to a given set of PDG codes.
     * 
     * Note that the given flux function will only be assigned to those files\n
     * whose header lists < b>all< /b> of the specified PDG codes as primaries.
     *
     * \param  types                       set of PDG codes
     * \param  flux                        flux function
     * \return                             number of modified event weighters
     */
    size_t setFlux(const std::set<int>& types,
		   const JFlux&         flux)
    {
      return setEvtWeightFactor<JFlux>(types, flux);
    }


    /**
     * Set flux function of all MC-files corresponding to a given multi-particle flux interface.
     * 
     * Note that the given flux functions will only be assigned to those files\n
     * whose header lists < b>all< /b> of the PDG codes associated with the multi-particle flux interface as primaries.
     *
     * \param  multiParticleFlux          multi-particle flux object
     * \return                            number of modified event weighters
     */
    size_t setFlux(const JEvtWeightFactorMultiParticle<JFlux>& multiParticleFlux)
    {
      return setEvtWeightFactor<JFlux>(multiParticleFlux);
    }


    /**
     * Function object for comparison of headers.
     */
    JComparator_t compare;
  };


}

#endif