#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <vector>
#include <set>

#include "JDetector/JTripod.hh"

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


namespace {
  
  using namespace JPP;

  /**
   * Wild card for tripod identifier.
   */
  static const int         WILDCARD    =  -1;

  static const std::string setx_t      = "setx";              //!< Set      East"
  static const std::string sety_t      = "sety";              //!< Set      North"
  static const std::string setz_t      = "setz";              //!< Set      depth
  static const std::string addx_t      = "addx";              //!< Add      East"
  static const std::string addy_t      = "addy";              //!< Add      North"
  static const std::string addz_t      = "addz";              //!< Add      depth
  static const std::string subx_t      = "subx";              //!< Subtract East"
  static const std::string suby_t      = "suby";              //!< Subtract North"
  static const std::string subz_t      = "subz";              //!< Subtract depth

  /**
   * Auxiliary class to apply tripod modifications.
   */
  struct JModifier {
    /**
     * Default constructor.
     */
    JModifier()
    {}


    /**
     * Apply modification to given tripod.
     *
     * \param  tripod      tripod
     * \return             true if valid action; else false
     */
    bool apply(JTripod& tripod) const
    {
      if      (action == setx_t)
        tripod.setUTMPosition(JUTMPosition(value, tripod.getUTMNorth(), tripod.getUTMZ()));
      else if (action == addx_t)
        tripod.add(JUTMPosition(value, 0.0, 0.0));
      else if (action == subx_t)
        tripod.sub(JUTMPosition(value, 0.0, 0.0));
      else if (action == sety_t)
        tripod.setUTMPosition(JUTMPosition(tripod.getUTMEast(), value, tripod.getUTMZ()));
      else if (action == addy_t)
        tripod.add(JUTMPosition(0.0, value, 0.0));
      else if (action == suby_t)
        tripod.sub(JUTMPosition(0.0, value, 0.0));
      else if (action == setz_t)
        tripod.setUTMPosition(JUTMPosition(tripod.getUTMEast(), tripod.getUTMNorth(), value));
      else if (action == addz_t)
        tripod.add(JUTMPosition(0.0, 0.0, value));
      else if (action == subz_t)
        tripod.sub(JUTMPosition(0.0, 0.0, value));
      else
	return false;

      return true;
    }


    /**
     * Read modifier from input.
     *
     * \param  in          input stream
     * \param  modifier    modifier
     * \return             input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JModifier& modifier)
    {
      return in >> modifier.id >> modifier.action >> modifier.value;
    }


    /**
     * Write modifier to output.
     *
     * \param  out         output stream
     * \param  modifier    modifier
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JModifier& modifier)
    {
      return out << modifier.id << ' ' << modifier.action << ' ' << modifier.value;
    }


    int         id;
    std::string action;
    double      value;
  };
}

/**
 * \file
 *
 * Auxiliary program to modify tripod configuration.
 *
 * Syntax:
 * <pre>
 *     -T "<tripod identifier>     (setx|addx|subx) East"
 *     -T "<tripod identifier>     (sety|addy|suby) North"
 *     -T "<tripod identifier>     (setz|addz|subz) depth"
 * </pre>
 *
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  string             tripodFile;
  vector<JModifier>  mod;
  size_t             size;
  int                debug;

  try {

    JParser<> zap("Auxiliary program to modify tripod configuration.");

    zap['f'] = make_field(tripodFile,  "tripod file I/O");
    zap['T'] = make_field(mod,         "tripod modifier")                    = JPARSER::initialised();
    zap['N'] = make_field(size,        "internal buffer size")               = 500000;
    zap['d'] = make_field(debug,       "debug level")                        = 2;

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


  fstream io;

  io.open(tripodFile.c_str(), ios_base::in | ios_base::out);

  if (!io) {
    FATAL("Error opening file " << tripodFile << endl);
  }

  typedef vector<JTripod> container_type;

  JComment       comment;
  container_type tripods;

  io >> comment;
  
  for (JTripod tripod; io >> tripod; ) {
    tripods.push_back(tripod);
  }

  if (debug >= debug_t) {

    cout << comment << endl;

    for (container_type::const_iterator i = tripods.begin(); i != tripods.end(); ++i) {
      cout << *i << endl;
    }
  }

  for (vector<JModifier>::const_iterator i = mod.begin(); i != mod.end(); ++i) {

    for (container_type::iterator target = tripods.begin(); target != tripods.end(); ++target) {

      if (target->getID() == i->id || i->id == WILDCARD) {

	DEBUG("Modifier"                                                << ' '
	      << "(" << FILL(2,'0') << target->getID() << FILL() << ")" << ' '
	      << i->action << ' ' << i->value << endl);

	if (!i->apply(*target)) {
	  ERROR("No valid action: " << *i << endl);
	}
      }
    }
  }

  //io.clear();
  //io.seekp(0, ios_base::beg);
  io.close();
  io.open(tripodFile.c_str(), ios_base::trunc | ios_base::out);

  for (container_type::const_iterator i = tripods.begin(); i != tripods.end(); ++i) {
    io << *i << endl;
  }

  io.close();
}