#ifndef __JBUILDL1__
#define __JBUILDL1__

#include <vector>
#include <iterator>
#include <algorithm>
#include <functional>
#include <iterator>

#include "JTools/JMergeSort.hh"

#include "JTrigger/JTriggerException.hh"
#include "JTrigger/JHitToolkit.hh"
#include "JTrigger/JSuperFrame.hh"
#include "JTrigger/JHitL1.hh"
#include "JGeometry3D/JAxis3D.hh"


namespace JTRIGGER {

  namespace {
    using JTOOLS::copy;
    using JTOOLS::merge;
    using JTOOLS::JMergeSort;
    using JGEOMETRY3D::JAxis3D;
  }


  /**
   * Template L1 builder.
   * An L1 hit is a local coincidence between two different PMTs in the same optical module.
   *
   * Note that this class heavily uses internal buffers.
   * This class should therefore be used as an I/O operator, rather than a constructor.
   *
   * The input data consists of a single super frame, containing time sorted frames for each PMT from one optical module.
   * Each data frame should be terminated with an appriopriate end marker.
   */
  template<class JElement_t>
  class JBuildL1 :
    public JHitToolkit<JElement_t>
  {
  public:
    /**
     * Constructor.
     *
     * \param  Tmax_ns        maximal time difference of L1 [ns]
     * \param  combine        combine multiple L1 within given time window 
     */
    JBuildL1(const double Tmax_ns,
	     const bool   combine = false) :
      TMaxLocal_ns(Tmax_ns),
      combineL1(combine)
    {}


    /**
     * Build L1 from super frame.
     *
     * \param  super_frame   input  data
     * \param  out           output data
     */
    template<template <class, class> class JContainer_t, class JAllocator_t>
    void operator()(const JSuperFrame<JElement_t>& super_frame, 
		    std::back_insert_iterator< JContainer_t<JElement_t, JAllocator_t> > out) const
    {
      int n = 0; 

      for (typename JSuperFrame<JElement_t>::const_iterator i = super_frame.begin(); i != super_frame.end(); ++i)
	n += i->size() - 1;

      if (n > 1) {

	merge(super_frame, buffer, this->getToolkit());

	for (typename std::vector<JElement_t>::const_iterator q = buffer.begin(), p = q++; n != 0; ++q, --n) {

	  if (getTimeDifference(*p,*q) < TMaxLocal_ns) {
	    
	    *out = *p;
	    ++out;

	    if (combineL1)
	      for (++q, --n; getTimeDifference(*p,*q) < TMaxLocal_ns; ++q, --n) {}
	  }
	
	  p = q;
	}
      }
    }


  protected:
    double TMaxLocal_ns;
    bool   combineL1;

  private:
    JMergeSort         <JElement_t> merge;
    mutable std::vector<JElement_t> buffer;
  };



  /**
   * Template specialisation for L1 builder with JHit (compatible) input and JHitL1 output.
   */
  template<>
  class JBuildL1<JHitL1> 
  {

    typedef std::vector<JHitL0>::const_iterator      const_iterator;
    typedef std::vector<JHitL0>::iterator            iterator;


  public:
    /**
     * Constructor.
     *
     * \param  Tmax_ns        maximal time difference between hits [ns]
     * \param  ct             minimal cosine between PMT axes
     */
    JBuildL1(const double Tmax_ns,
	     const double ct = 0.0) :
      TMaxLocal_ns(Tmax_ns),
      ctMin       (ct),
      buffer ()
    {}


    /**
     * Build L1 from super frame.
     *
     * \param  super_frame   input  data
     * \param  out           output data
     */
    template<class JElement_t, template<class> class JContainer_t>
    void operator()(const JSuperFrame<JElement_t>& super_frame, 
		    std::back_insert_iterator< JContainer_t<JHitL1> > out) const
    {
      int n = 0;

      for (typename JSuperFrame<JElement_t>::const_iterator i = super_frame.begin(); i != super_frame.end(); ++i)
	n += i->size();

      buffer.resize(n);

      {
	iterator p = buffer.begin();

	for (typename JSuperFrame<JElement_t>::const_iterator frame = super_frame.begin(); frame != super_frame.end(); ++frame) {
	
	  const JDAQPMTIdentifier pmtID(super_frame.getModuleID(), frame->getPMTAddress());
	  const JAxis3D&          axis = frame->getAxis();

	  for (typename JSuperFrame<JElement_t>::value_type::const_iterator i = frame->begin(); i != frame->end(); ++i, ++p)
	    *p = JHitL0(pmtID, axis, JHit(*i));
	}
      }


      std::sort(buffer.begin(), buffer.end(), std::less<JHit>());

      
      for (const_iterator p = buffer.begin(); p != buffer.end(); ) {

	double t1 = p->getT();

	const_iterator q = p;

	for (++q; q != buffer.end() && q->getT() - t1 < TMaxLocal_ns; ++q)
	  t1 = q->getT();

	if (std::distance(p,q) > 1) {

	  int m = 0;

	  for (const_iterator i = p; i != q; ++i) {
	    for (const_iterator j = i; ++j != q; ) {
	      if (dot(i->getDirection(), j->getDirection()) >= ctMin)
		++m;
	    }
	  }

	  if (m != 0) {

	    JHitL1 hit(super_frame.getModuleID());
	    
	    copy(p, q, back_inserter(hit));

	    *out = hit;
	    ++out;
	  }
	}

	p = q;
      }
    }


    double TMaxLocal_ns;
    double ctMin;

  private:
    mutable std::vector<JHitL0> buffer;
  };
}

#endif