#ifndef __JDAQTIMESLICE__
#define __JDAQTIMESLICE__

#include <ostream>
#include <iomanip>
#include <vector>
#include <map>
#include <algorithm>

#include "Jeep/JPrint.hh"
#include "JDAQ/JDAQRoot.hh"
#include "JDAQ/JDAQPreamble.hh"
#include "JDAQ/JDAQSuperFrame.hh"
#include "JDAQ/JDAQTimesliceHeader.hh"
#include "JDAQ/JDAQEvent.hh"
#include "JDAQ/JDAQException.hh"
#include "JIO/JSerialisable.hh"
#include "JIO/JIOLibrary.hh"


namespace KM3NETDAQ {

  namespace {
    using JIO::JReader;
    using JIO::JWriter;
  }


  /**
   * Data time slice.
   */
  class JDAQTimeslice :
    public JDAQPreamble,
    public JDAQTimesliceHeader,
    public std::vector<JDAQSuperFrame>
  {
  public:
    /**
     * Default constructor.
     */
    JDAQTimeslice() :
      JDAQPreamble(JLANG::JType<JDAQTimeslice>()),
      JDAQTimesliceHeader(),
      std::vector<JDAQSuperFrame>()
    {}


    /**
     * Constructor.
     *
     * \param  event          DAQ event
     * \param  snapshot       use shapshot hits
     */
    JDAQTimeslice(const JDAQEvent& event,
		  const bool       snapshot = false) :
      JDAQPreamble(JLANG::JType<JDAQTimeslice>()),
      JDAQTimesliceHeader(event.getDAQChronometer()),
      std::vector<JDAQSuperFrame>()
    {
      using namespace std;

      map<int, vector<JDAQHit> > buffer;

      if (snapshot) {
	for (vector<JDAQSnapshotHit>::const_iterator  hit = event.begin<JDAQSnapshotHit> (); hit != event.end<JDAQSnapshotHit> (); ++hit)
	  buffer[hit->getModuleID()].push_back(*hit);
      } else {
	for (vector<JDAQTriggeredHit>::const_iterator hit = event.begin<JDAQTriggeredHit>(); hit != event.end<JDAQTriggeredHit>(); ++hit)
	  buffer[hit->getModuleID()].push_back(*hit);
      }


      for (map<int, vector<JDAQHit> >::iterator entry = buffer.begin(); entry != buffer.end(); ++entry) {

	if (!entry->second.empty()) {

          sort(entry->second.begin(), entry->second.end());

	  this->push_back(JDAQSuperFrame(JDAQSuperFrameHeader(getDAQChronometer(), entry->first)));

	  this->rbegin()->add(entry->second.size(), entry->second.data());
	}
      }
    }


    /**
     * Virtual destructor.
     */
    virtual ~JDAQTimeslice()
    {
      clear();
    }


    /**
     * Clear data.
     */
    void clear()
    {
      for (iterator i = this->begin(); i != this->end(); ++i)
	i->clear();
    }


    /**
     * Assignment operator.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& operator=(const JDAQTimeslice& timeslice)
    {
      clear();

      setDAQChronometer(timeslice.getDAQChronometer());

      for (const_iterator i = timeslice.begin(); i != timeslice.end(); ++i)
	push_back(*i);

      return *this;
    }


    /**
     * Add another timeslice.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& add(const JDAQTimeslice& timeslice) 
    {
      using namespace std;

      map<JDAQModuleIdentifier, int> buffer;

      for (const_iterator i = this->begin(); i != this->end(); ++i)
	buffer[i->getModuleIdentifier()] = distance(static_cast<const JDAQTimeslice&>(*this).begin(),i);

      for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {

	map<JDAQModuleIdentifier, int>::const_iterator p = buffer.find(i->getModuleIdentifier());
	
	if (p != buffer.end()) {

	  JDAQSuperFrame& frame = this->at(p->second);

	  frame.add(*i);
	  sort(frame.begin(), frame.end());

	} else

	  this->push_back(*i);
      }
      
      return *this;
    }


    /**
     * Read DAQ timeslice from input.
     *
     * \param  in             JReader
     * \param  timeslice      JDAQTimeslice
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JDAQTimeslice& timeslice)
    {
      timeslice.clear();

      in >> static_cast<JDAQPreamble&>               (timeslice);
      in >> static_cast<JDAQTimesliceHeader&>        (timeslice);
      in >> static_cast<std::vector<JDAQSuperFrame>&>(timeslice);

      return in;
    }


    /**
     * Write DAQ timeslice to output.
     *
     * \param  out           JWriter
     * \param  timeslice     JDAQTimeslice
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JDAQTimeslice& timeslice)
    {
      out << static_cast<const JDAQPreamble&>               (timeslice);
      out << static_cast<const JDAQTimesliceHeader&>        (timeslice);
      out << static_cast<const std::vector<JDAQSuperFrame>&>(timeslice);

      return out;
    }


    /**
     * Print DAQ Timeslice.
     *
     * \param  out           output stream
     * \param  lpr           long print
     * \return               output stream
     */
    ostream& print(ostream& out, const bool lpr = false) const
    {
      using namespace std;
      
      out << this->ClassName() << newline;
      out << dynamic_cast<const JDAQPreamble&>   (*this) << newline;
      out << dynamic_cast<const JDAQChronometer&>(*this) << newline;
      
      for (JDAQTimeslice::const_iterator frame = this->begin(); frame != this->end(); ++frame) {
	
	out << ' ' << setw(5)  << frame->getModuleID();
	out << ' ' << setw(6)  << frame->getLength();
	out << ' ' << setw(6)  << frame->getDataType();
	out << ' ' << setw(6)  << frame->size();
	
	if (!lpr) {
	  
	  if (!frame->empty()) {
	    
	    out << ' ' << setw(10) << frame-> begin()->getT();
	    out << " ... ";
	    out << ' ' << setw(10) << frame->rbegin()->getT();
	  }
	  
	  out << newline;
	  
	} else {
	  
	  out << newline;
	  
	  int n = 1;
	  
	  for (JDAQFrame::const_iterator hit = frame->begin(); hit != frame->end(); ++hit, ++n)
	    out << setw(2) << (int) hit->getPMT() << ' ' << setw(8) << hit->getT() << (n%10 == 0 ? newline : whitespace);
	  
	  out << newline;
	}
      }

      return out;
    }

    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    virtual int getSize() const
    { 
      int len = 0;

      len += JDAQPreamble       ::sizeOf();
      len += JDAQTimesliceHeader::sizeOf();

      len += sizeof(int);

      for (const_iterator frame = begin(); frame != end(); ++frame)
	len += frame->getSize();

      return len;
    }


    ClassDef(JDAQTimeslice,1);
  };


  /**
   * Print DAQ Timeslice.
   *
   * \param  out           output stream
   * \param  timeslice     timeslice
   * \return               output stream
   */
  inline ostream& operator<<(ostream& out, const JDAQTimeslice& timeslice)
  {
    return timeslice.print(out, getLongprint(out));
  }
}

#endif