#ifndef __JACOUSTICS__JTRANSMISSION__
#define __JACOUSTICS__JTRANSMISSION__

#include <cmath>

#include <TROOT.h>
#include <TObject.h>

#include "JIO/JSerialisable.hh"


/**
 * \file
 *
 * Acoustic transmission.
 * \author mdejong
 */
namespace JACOUSTICS {}
namespace JPP { using namespace JACOUSTICS; }

namespace JACOUSTICS {

  using JIO::JReader;
  using JIO::JWriter;

  /**
   * Acoustic transmission.
   */
  struct JTransmission :
    public TObject
  {
    /**
     * Default constructor.
     */
    JTransmission() :
      run(-1),
      id (-1),
      q  (0.0),
      w  (0.0),
      toa(0.0),
      toe(0.0)
    {}


    /**
     * Constructor.
     *
     * \param  run            run number
     * \param  id             identifier
     * \param  Q              quality
     * \param  W              normalisation
     * \param  toa_s          time-of-arrival  [s]
     * \param  toe_s          time-of-emission [s]
     */
    JTransmission(const int    run,
		  const int    id,
		  const double Q,
		  const double W,
		  const double toa_s,
		  const double toe_s) :
      run(run),
      id (id),
      q  (Q),
      w  (W),
      toa(toa_s),
      toe(toe_s)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JTransmission()
    {}


    /**
     * Get run number.
     *
     * \return                run number
     */
    int getRunNumber() const
    {
      return run;
    }


    /**
     * Get identifier.
     *
     * \return                identifier
     */
    int getID() const
    {
      return id;
    }


    /**
     * Get quality.
     *
     * \return                quality
     */
    double getQ() const
    {
      return q;
    }


    /**
     * Get normalisation.
     *
     * \return                normalisation
     */
    double getW() const
    {
      return w;
    }


    /**
     * Get calibrated time of arrival.
     *
     * \return                time [s]
     */
    double getToA() const
    {
      return toa;
    }


    /**
     * Get estimated time of emission.
     *
     * \return                time [s]
     */
    double getToE() const
    {
      return toe;
    }


    /**
     * Set estimated time of emission.
     *
     * \param  toe            time [s]
     */
    void setToE(const double toe)
    {
      this->toe = toe;
    }


    /**
     * Read transmission from input.
     *
     * \param  in             reader
     * \param  object         transmission
     * \return                reader
     */
    friend inline JReader& operator>>(JReader& in, JTransmission& object)
    {
      in >> object.run;
      in >> object.id;
      in >> object.q;
      in >> object.w;
      in >> object.toa;
      in >> object.toe;

      return in;
    }


    /**
     * Write transmission to output.
     *
     * \param  out           writer
     * \param  object        transmission
     * \return               writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTransmission& object)
    {
      out << object.run;
      out << object.id;
      out << object.q;
      out << object.w;
      out << object.toa;
      out << object.toe;

      return out;
    }

    ClassDef(JTransmission, 3);

    /**
     * Auxiliary class to compare transmissions.
     */
    struct equals {
      /**
       * Constructor.
       *
       * \param  precision       time-of-arrival precision [s]
       */
      equals(const double precision) :
	precision(precision)
      {}


      /**
       * Compare two transmissions.
       *
       * \param  first           first  transmission
       * \param  second          second transmission
       * \return                 true if times-of-arrival are similar; else false
       */
      bool operator()(const JTransmission& first, const JTransmission& second) const
      {
	return fabs(first.getToA() - second.getToA()) <= precision;
      }

      const double precision;
    };


    /**
     * Auxiliary class to compare transmissions.
     */
    struct compare :
      public equals
    {
      /**
       * Constructor.
       *
       * \param  precision       time-of-arrival precision [s]
       */
      compare(const double precision) :
	equals(precision)
      {}


      /**
       * Compare two transmissions.
       *
       * The transmission wih the earliest time-of-arrival comes first.\n
       * If the two transmissions are equal within the specified precision,
       * the transmission with the highest quality comes first.\n
       * If also the qualities are the same, the time-of-arrival is again used.
       *
       * \param  first           first  transmission
       * \param  second          second transmission
       * \return                 true if time-of-arrival of first transmission earlier than that of second; else false
       */
      bool operator()(const JTransmission& first, const JTransmission& second) const
      {
	if (static_cast<const equals&>(*this)(first, second)) {

	  if (first.getQ() == second.getQ())
	    return first.getToA() < second.getToA();
	  else
	    return first.getQ()   > second.getQ();

	} else {

	  return first.getToA() < second.getToA();
	}
      }
    };

  protected:
    int    run;
    int    id;
    double q;
    double w;
    double toa;
    double toe;
  };


  /**
   * Less-than operator for two transmissions.
   *
   * The less-than operator is first applied to the time-of-emission and then to the identifier.
   *
   * \param  first          first  transmission
   * \param  second         second transmission
   * \return                true if first transmission earlier than second; else false
   */
  static inline bool operator<(const JTransmission& first, const JTransmission& second)
  {
    if (first.getToE() == second.getToE())
      return first.getID()  < second.getID();
    else
      return first.getToE() < second.getToE();
  }


  /**
   * Equals operator for two transmissions.
   *
   * The equal operator is applied to the time-of-emission and the identifier.
   *
   * \param  first          first  transmission
   * \param  second         second transmission
   * \return                true if first transmission equal to second; else false
   */
  static inline bool operator==(const JTransmission& first, const JTransmission& second)
  {
    return (first.getID()  == second.getID()   &&
	    first.getToE() == second.getToE());
  }
}

#endif