#include <iostream>
#include <iomanip>
#include <limits>
#include <map>
#include <algorithm>

#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile2D.h"

#include "JTools/JHashCollection.hh"
#include "JTools/JHashMap.hh"
#include "JTools/JRange.hh"
#include "JTools/JQuantile.hh"

#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTripod.hh"
#include "JDetector/JTransmitter.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"

#include "JROOT/JRootToolkit.hh"
#include "JROOT/JManager.hh"

#include "JLang/JComparator.hh"

#include "JAcoustics/JEmitter.hh"
#include "JAcoustics/JEvent.hh"
#include "JAcoustics/JSupport.hh"

#include "Jeep/JContainer.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

namespace {

  using JDETECTOR::JLocation;
  using JGEOMETRY3D::JPosition3D;

  /**
   * Auxilisry data structure for module location and position.
   */
  struct JModule_t :  
    public JLocation,
    public JPosition3D
  {
    /**
     * Default constructor.
     */
    JModule_t()
    {}

    /**
     * Constructor.
     *
     * \param  location      location
     * \param  position      position
     */
    JModule_t(const JLocation&   location,
	      const JPosition3D& position) :
      JLocation  (location),
      JPosition3D(position)
    {}
  };
}


/**
 * \file
 *
 * Example program to monitor acoustic events.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  typedef JContainer< vector<JTripod> >      tripods_container;
  typedef JContainer< vector<JTransmitter> > transmitters_container;

  JMultipleFileScanner<>  inputFile;
  JLimit_t&               numberOfEvents = inputFile.getLimit();
  string                  outputFile;
  string                  detectorFile;
  tripods_container       tripods;                              // tripods
  transmitters_container  transmitters;                         // transmitters
  double                  Q;
  int                     debug;

  try {

    JParser<> zap("Example program to monitor acoustic events.");

    zap['f'] = make_field(inputFile,       "output of JAcousticEventBuilder[.sh]");
    zap['n'] = make_field(numberOfEvents)   = JLimit::max();
    zap['o'] = make_field(outputFile)       = "monitor.root";
    zap['a'] = make_field(detectorFile);
    zap['T'] = make_field(tripods,         "tripod data")                    = JPARSER::initialised();
    zap['Y'] = make_field(transmitters,    "transmitter data")               = JPARSER::initialised();
    zap['Q'] = make_field(Q)                = 0.9;
    zap['d'] = make_field(debug)            = 2;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }

  JDetector detector;

  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }

  sort(detector.begin(), detector.end(), make_comparator(&JModule::getLocation));

  JHashMap<int, JModule_t>   receivers;
  JHashMap<int, JPosition3D> emitters;
  
  for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
    receivers[i->getID()] = JModule_t(i->getLocation(), i->getPosition());
  }

  for (tripods_container::const_iterator i = tripods.begin(); i != tripods.end(); ++i) {
    emitters[i->getID()]  = (i->getUTMPosition() - detector.getUTMPosition());
  }

  for (transmitters_container::const_iterator i = transmitters.begin(); i != transmitters.end(); ++i) {
    try {
      emitters[i->getID()]  = (i->getPosition() + detector.getModule(i->getLocation()).getPosition());
    }
    catch(const exception&) {
      continue;                                                       // if no module available, discard transmitter
    }
  }

  const JHashCollection<int> string(make_array(detector.begin(), detector.end(), &JModule::getString));
  const JRange         <int> floor (make_array(detector.begin(), detector.end(), &JModule::getFloor));

  JManager<int, TH1D> HA(new TH1D("H[%].size",         NULL, detector.size() + 1, -0.5, detector.size() + 0.5));
  JManager<int, TH1D> HB(new TH1D("H[%].overlays",     NULL, 201, -0.5, 200.5));
  JManager<int, TH1D> HC(new TH1D("H[%].time",         NULL, 800,  0.0,   4.0));
  JManager<int, TH1D> HD(new TH1D("H[%].rms",          NULL, 500,  0.0,   1.0e-1));
  JManager<int, TH1D> HE(new TH1D("H[%].quantile",     NULL, 500,  0.0,   1.0e-1));
  JManager<int, TH1D> HQ(new TH1D("H[%].quality",      NULL, 200,  0.0,   8.0));
  JManager<int, TH2D> HR(new TH2D("H[%].QR",           NULL, 40, 1.5, 3.5, 40, 3.0, 7.0)); 
  JManager<int, TH1D> H1(new TH1D("H[%].multiplicity", NULL, 101, -0.5, 100.5));
  JManager<int, TH2D> H2(new TH2D("H[%].event",        NULL,
				  string.size(),              -0.5, string.size()         - 0.5, 
				  floor.getUpperLimit() + 1, - 0.5, floor.getUpperLimit() + 0.5));
  JManager<int, TProfile2D> H4(new TProfile2D("H[%].log10(Q)",        NULL,
					      string.size(),              -0.5, string.size()         - 0.5, 
					      floor.getUpperLimit() + 1, - 0.5, floor.getUpperLimit() + 0.5));

  for (Int_t i = 1; i <= H2->GetXaxis()->GetNbins(); ++i) {
    H2->GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string.at(i-1)));
  }

  for (Int_t i = 1; i <= H2->GetYaxis()->GetNbins(); ++i) {
    H2->GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
  }

  for (Int_t i = 1; i <= H4->GetXaxis()->GetNbins(); ++i) {
    H4->GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string.at(i-1)));
  }

  for (Int_t i = 1; i <= H4->GetYaxis()->GetNbins(); ++i) {
    H4->GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
  }

  JManager<int, TH2D> H3((TH2D*) H2->Clone("H[%].doubles"));

  for (JHashMap<int, JPosition3D>::const_iterator i = emitters.begin(); i != emitters.end(); ++i) {
    H2[i->first];
    H3[i->first];
  }

  typedef JTreeScanner<JEvent, JEvent::JEvaluator>  JTreeScanner_t;

  counter_type counter = 0;
  
  for (JMultipleFileScanner<>::const_iterator i = inputFile.begin(); i != inputFile.end(); ++i) {

    JTreeScanner_t in(*i);

    JHashMap<int, double> toe;

    for (JTreeScanner_t::iterator event = in.begin(); event != in.end() && counter != inputFile.getLimit(); ++event, ++counter) {

      if (counter%1000 == 0) {
	STATUS("event " << setw(8) << counter << '\r'); DEBUG(endl);
      }

      const JEvent evt = *event;

      JQuantile Q1("", true);

      for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
	Q1.put(i->getToE());
      }

      HA[evt.getID()]->Fill((double) evt.size());
      HB[evt.getID()]->Fill((double) evt.getOverlays());

      if (toe.has(evt.getID())) {
	HC[evt.getID()]->Fill(log10(evt.begin()->getToE() - toe[evt.getID()]));
      }

      HD[evt.getID()]->Fill(Q1.getSTDev());
      HE[evt.getID()]->Fill(Q1.getQuantile(Q, JQuantile::symmetric_t));
    
      toe[evt.getID()] = evt.begin()->getToE();

      TH1D* hq = HQ[evt.getID()];
      TH2D* hr = HR[evt.getID()];
      TH1D* h1 = H1[evt.getID()];
      TH2D* h2 = H2[evt.getID()];
      TH2D* h3 = H3[evt.getID()];
      TProfile2D* h4 = H4[evt.getID()];

      for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
	hq->Fill(log10(i->getQ()));
      }

      if (emitters.has(evt.getID())) {

	const JPosition3D& p0 = emitters[evt.getID()];
      
	for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
	  if (receivers.has(i->getID())) {
	    HR->Fill(log10(p0.getDistance(receivers[i->getID()])), log10(i->getQ()));
	    hr->Fill(log10(p0.getDistance(receivers[i->getID()])), log10(i->getQ()));
	  }
	}
      }
      
      map<int, set<double> > buffer;

      for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
	buffer[i->getID()].insert(i->getQ());
      }

      for (map<int, set<double> >::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {

	h1->Fill((double) i->second.size());

	if (receivers.has(i->first)) {

	  const JLocation& location = receivers[i->first];

	  const double x = string.getIndex(location.getString());
	  const double y = location.getFloor();

	  h2->Fill(x, y, 1.0);

	  if (i->second.size() >= 2u) {
	    h3->Fill(x, y, 1.0);
	  }

	  h4->Fill(x, y, log10(*(i->second.rbegin())));
	}
      }
    }
  }
  STATUS(endl);


  TFile out(outputFile.c_str(), "recreate");

  out << HA << HB << HC << HD << HE << HQ << HR << *HR << H1 << H2 << H3 << H4;

  out.Write();
  out.Close();
}