#ifndef __JACOUSTICS__JNARRABRI__
#define __JACOUSTICS__JNARRABRI__

#include <limits>

#include "JDetector/JDetector.hh"

#include "JLang/JObjectIterator.hh"

#include "Jeep/JContainer.hh"

#include "JTools/JHashMap.hh"
#include "JTools/JSpline.hh"
#include "JTools/JPolfit.hh"
#include "JTools/JElement.hh"
#include "JTools/JCollection.hh"

#include "JAcoustics/JModel.hh"
#include "JAcoustics/JGeometry.hh"
#include "JAcoustics/JEvt.hh"


/**
 * \file
 *
 * Dynamic position calibration.
 * \author mdejong
 */
namespace JACOUSTICS {}
namespace JPP { using namespace JACOUSTICS; }

namespace JACOUSTICS {

  using JDETECTOR::JDetector;
  using JLANG::JObjectIterator;
  using JEEP::JContainer;


  /**
   * Dynamic position calibration.
   */
  struct JNarrabri {

    enum {
      NUMBER_OF_POINTS  = 7,    //!< number of points  for interpolation
      NUMBER_OF_DEGREES = 2     //!< number of degrees for interpolation
    };

    typedef JTOOLS::JElement2D<double, JMODEL::JString>                     element_type;
    typedef JTOOLS::JPolfitFunction1D<NUMBER_OF_POINTS,
				      NUMBER_OF_DEGREES,
				      element_type, JTOOLS::JCollection>    function_type;

    typedef JTOOLS::JHashMap<int, function_type>                            data_type;

    typedef data_type::const_iterator                                       const_iterator;
    typedef data_type::const_reverse_iterator                               const_reverse_iterator;


    /**
     * Constructor.
     *
     * \param  detector                 detector
     * \param  Tmax_s                   applicability period [s]
     */
    JNarrabri(const JDetector& detector,
	      const double     Tmax_s) :
      detector(detector),
      geometry(detector),
      Tmax_s(Tmax_s),
      t0_s(std::numeric_limits<double>::lowest())
    {}


    /**
     * Load calibration data.
     *
     * \param  input                    detector calibration data
     */
    void load(JObjectIterator<JEvt>& input)
    {
      t0_s = std::numeric_limits<double>::lowest();

      while (input.hasNext()) {

	const JEvt*  evt  = input.next();
	const double t1_s = 0.5 * (evt->UNIXTimeStart + evt->UNIXTimeStop);

	for (JEvt::const_iterator i = evt->begin(); i != evt->end(); ++i) {
	  calibration[i->id][t1_s] = JMODEL::JString(i->tx, i->ty);
	}
      }

      for (data_type::iterator i = calibration.begin(); i != calibration.end(); ++i) {
	i->second.compile();
      }
    }


    /**
     * Check validity of calibration.
     *
     * \return                          true if valid; else false
     */
    bool is_valid() const
    {
      for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {
	if (!calibration.has(module->getString())) {
	  return false;
	}
      }

      return true;
    }


    /**
     * Get minimal abscissa.
     *
     * \return                           minimal abscissa
     */
    double getXmin() const
    {
      double xmin = std::numeric_limits<double>::max();

      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (!i->second.empty() && i->second.getXmin() < xmin) {
          xmin = i->second.getXmin();
        }
      }

      return xmin;
    }


    /**
     * Get maximal abscissa.
     *
     * \return                           maximal abscissa
     */
    double getXmax() const
    {
      double xmax = std::numeric_limits<double>::lowest();

      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (!i->second.empty() && i->second.getXmax() > xmax) {
          xmax = i->second.getXmax();
        }
      }

      return xmax;
    }


    const_iterator         begin()  const { return calibration.begin(); }    //!< begin of calibration data
    const_iterator         end()    const { return calibration.end(); }      //!< end   of calibration data
    const_reverse_iterator rbegin() const { return calibration.rbegin(); }   //!< begin of reverse of calibration data
    const_reverse_iterator rend()   const { return calibration.rend(); }     //!< begin of reverse of calibration data


    /**
     * Get detector calibrated at given time.
     *
     * \param  t1_s                     time [s]
     * \return                          detector
     */
    const JDetector& operator()(const double t1_s) 
    {
      using namespace std;
      using namespace JPP;

      if (!calibration.empty()) {

	if (fabs(t1_s - t0_s) > Tmax_s) {

	  JHashMap<int, JMODEL::JString> buffer;

	  for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {

	    if (!buffer.has(module->getString())) {
	      if (calibration.has(module->getString())) {
		buffer[module->getString()] = calibration[module->getString()](t1_s);
	      }
	    }

	    if (buffer.has(module->getString())) {
	      module->set(geometry[module->getString()].getPosition(buffer[module->getString()], module->getFloor())  -  getPiezoPosition());
	    }
	  }

	  t0_s = t1_s;
	}
      }

      return detector;
    }


  protected:
    data_type  calibration;
    JDetector  detector;
    JGeometry  geometry;
    double     Tmax_s;

  private:
    double     t0_s;
  };
}

#endif