#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>

#include "JDB/JDB.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JRunQuality.hh"
#include "JDB/JRunsetups.hh"
#include "JDB/JDBToolkit.hh"

#include "JLang/JLangToolkit.hh"
#include "JTools/JRange.hh"

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

#include "JDataQuality/JGITTags.hh"

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

/**
 * \file
 *
 * Main program to print quality data from data base.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  typedef JRange<int>           JRange_t; 

  JServer         server;
  string          usr;
  string          pwd;
  string          cookie;
  string          inputFile;
  string          outputFile;
  string          detid;
  JRange_t        runs;
  vector<string>  source;
  TRegexp         regexp(".");
  JSelector       selection;
  vector<string>  format;
  int             debug;

  try {

    JParser<> zap("Main program to print quality data from data base.");
        
    zap['s'] = make_field(server)        = getServernames();
    zap['u'] = make_field(usr)           = "";
    zap['!'] = make_field(pwd)           = "";
    zap['C'] = make_field(cookie)        = "";
    zap['D'] = make_field(detid);
    zap['R'] = make_field(runs,       "Run range")                                      = JRange_t(1, JRange_t::getMaximum());
    zap['S'] = make_field(source,     "GIT versions")                                   = getGITTags(TRegexp("v[0-9]*\\.[0-9]*\\.[0-9]*$"), JGITTags_t::key_type("2019-04-12"));
    zap['r'] = make_field(regexp,     "TRegexp for selection of run setup names.")      = JPARSER::initialised();
    zap['F'] = make_field(format,     "column names: " << JEEPZ() << getColumns<JRunQuality>()) = JPARSER::initialised();
    zap['@'] = make_field(selection)     = JPARSER::initialised();
    zap['d'] = make_field(debug,      "Debug level")                                    = 1;

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


  JRunsetups       setups;                  // run -> value
  set<JRunQuality> buffer;                  // storage

  try {

    JDB::reset(usr, pwd, cookie);
      
    const int ID = getDetector<int>   (detid);
    detid        = getDetector<string>(detid);

    // run setups

    selection += getSelector<JRuns>(ID, runs.getLowerLimit(), runs.getUpperLimit());

    ResultSet& rs  = getResultSet(getTable<JRuns>(), selection);

    for (JRuns parameters; rs >> parameters; ) {
      if (TString(parameters.RUNSETUPNAME.c_str()).Contains(regexp)) {
	setups.put(parameters);
      }
    }

    rs.Close();
    
    // run summary data

    for (vector<string>::const_iterator git = source.begin(); git != source.end() && buffer.size() < setups.size(); ++git) {

      typedef map<string, string>    data_type;
      typedef map<int, data_type>    map_type;

      map_type zmap;

      JSelector selector = getSelector<JRunSummaryNumbers>(detid, runs.getLowerLimit(), runs.getUpperLimit());

      selector.add(&JRunSummaryNumbers::SOURCE_NAME, *git);

      try {

	ResultSet& rs  = getResultSet(getTable<JRunSummaryNumbers>(), selector);

	for (JRunSummaryNumbers parameters; rs >> parameters; ) {
	  if (setups.count(parameters.RUN) != 0) {
	    zmap[parameters.RUN].insert(make_pair(parameters.PARAMETER_NAME, parameters.DATA_VALUE));
	  }
	}

	rs.Close();
      }
      catch(const exception& error) {}

      for (map_type::const_iterator run = zmap.begin(); run != zmap.end(); ++run) {
	
	JRunQuality quality;
	  
	quality.GIT      = *git;
	quality.detector = ID;
	quality.run      = run->first;
	quality.name     = setups[run->first].name;
	quality.value    = setups[run->first].value;

	for (data_type::const_iterator i = run->second.begin(); i != run->second.end(); ++i) {
	  quality.put(i->first, i->second);
	}

	buffer.insert(quality);           // only insert if absent
      }
    }
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }


  for (set<JRunQuality>::const_iterator quality = buffer.begin(); quality != buffer.end(); ++quality) {

    for (vector<string>::const_iterator i = format.begin(); i != format.end(); ++i) {
      JRootPrinter::print(cout, *quality, *i);
    }

    cout << endl;
  }

  return 0;
}