#include "Mapping.h"
#include <iomanip>
#include <argp.h>

//use when to compile on outdated slc
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

//============================================================================
// Stuff for ARGP
const char *argp_program_version = "ConvertPadRowToChannelFile.app";
const char *argp_program_bug_address = "<christian.lippmann@cern.ch>";
static char doc[] = "This program dumps the hardware addresses of all pads on a given padrow.";
static char args_doc[] = "";

//============================================================================
// The options ARGP understands
static struct argp_option options[] = {
  {"side",   's', "ROC",    0,  "Specify the side (0,1)."                  },
  {"sector", 'r', "ROC",    0,  "Specify the sector (0..17)"               },
  {"roc",    'c', "ROC",    0,  "Specify the ROC: 0 for IROC, 1 for OROC." },
  {"padrow", 'p', "PADROW", 0,  "Specify the PADROW."                      },
  { 0 }
};

//============================================================================
// Used by main to communicate with ARGP parse_opt
struct arguments {
  int32_t side, sector, roc, row;
};

//============================================================================
//Get the input argument from argp_parse, which is a pointer to the ARGP arguments structure.
static error_t parse_opt (int key, char *arg, struct argp_state *state) {
  struct arguments *arguments = (struct arguments*)state->input;

  switch (key) {   // Parse a single option

  case 's':
    arguments->side = atoi(arg);
    break;

  case 'r':
    arguments->sector = atoi(arg);
    break;

  case 'c':
    arguments->roc = atoi(arg);
    break;

  case 'p':
    arguments->row = atoi(arg);
    break;

  default:
    return ARGP_ERR_UNKNOWN;

  }

  return 0;
}

//============================================================================
static struct argp argp = { options, parse_opt, args_doc, doc };


int main( int argc, char** argv ) {

  struct arguments arguments;

  // Default values
  arguments.side   = -1;
  arguments.sector = -1;
  arguments.roc    = -1;
  arguments.row    = -1;

  // Parse arguments; every option seen by parse_opt will be reflected in arguments
  argp_parse (&argp, argc, argv, 0, 0, &arguments);

  Mapping pm;

  // 1) Which RCU
  int32_t rcu = -1;
  if ( arguments.roc<0 ) {
    cerr << "Error: ROC has to be specified! 0 for IROC, 1 for OROC." << endl;
    return 1;
  } else if ( arguments.roc==0 ) {
    int32_t min0 = pm.GetMinPadRow(0);
    int32_t max0 = pm.GetMaxPadRow(0);
    int32_t min1 = pm.GetMinPadRow(1);
    int32_t max1 = pm.GetMaxPadRow(1);
    if ( (arguments.row == max0) && (arguments.row==min1) ) {
      cerr << "Error: This padrow is shared between RP0 and RP1. Not supported yet." << endl;
      return 1;
    } else if ( arguments.row < min0 ) {
      cerr << "Error: Padrow not specified." << endl;
      return 1;
    } else if ( arguments.row < max0 ) {
      rcu=0;
    } else if ( arguments.row <= max1 ) {
      rcu=1;
    } else {
      cerr << "Error: Padrow too large for an IROC." << endl;
      return 1;
    }
  } else if ( arguments.roc==1 ) {
    int32_t min2 = pm.GetMinPadRow(2);
    int32_t max2 = pm.GetMaxPadRow(2);
    int32_t min3 = pm.GetMinPadRow(3);
    int32_t max3 = pm.GetMaxPadRow(3);
    int32_t max4 = pm.GetMaxPadRow(4);
    int32_t min5 = pm.GetMinPadRow(5);
    int32_t max5 = pm.GetMaxPadRow(5);
    if ( (arguments.row == max2) && (arguments.row==min3) ) {
      cerr << "Error: This padrow is shared between RP2 and RP3. Not supported yet." << endl;
      return 1;
    } else if ( (arguments.row == max4) && (arguments.row==min5) ) {
      cerr << "Error: This padrow is shared between RP4 and RP5. Not supported yet." << endl;
      return 1;
    } else if ( arguments.row < min2 ) {
      cerr << "Error: Padrow not specified." << endl;
      return 1;
    } else if ( arguments.row < max2 ) {
      rcu=2;
    } else if ( arguments.row <= max3 ) {
      rcu=3;
    } else if ( arguments.row < max4 ) {
      rcu=4;
    } else if ( arguments.row <= max5 ) {
      rcu=5;
    } else {
      cerr << "Error: Padrow too large." << endl;
      return 1;
    }
  } else {
    cerr << "Error: ROC is out of range (0,1)!" << endl;
    return 1;
  }

  cout << "RCU: " << rcu << endl;

  int32_t ctr = 0;

  cout << "--------------" << endl;
  cout << 14 << endl;
  cout << "Number\tSide\tSector\tRCU\tHwAdd\tData" << endl;
  for ( int32_t pad=0; pad<pm.GetPadsPerRow(arguments.row, rcu); pad++ ) {
    cout << ctr++ << "\t" << arguments.side << "\t" << arguments.sector << "\t" << rcu << "\t"
	 << pm.GetHWAddress(arguments.row, pad, rcu) << "\t" << -1 << endl;
  }

  return 0;
}