#include "o815.h"

#include <sstream>
#include <iomanip>
#include <cstring>

#ifndef MPI_DISABLED
#include <mpi.h>
#endif

#include "latlib/progress.h"

using namespace std;

extern int opterr;

o815::o815(int argc, char **argv, const string& _programid, comoption specOps[], void (*helpHeader)()) {
  programid = _programid;

  comargs.nmeas = 100;
  comargs.nskip = 10;
  comargs.nequi = 100;
  comargs.lsize[0] = 4;
  comargs.lsize[1] = 4;
  comargs.obscache = make_pair("",0);
  comargs.confcache = make_pair("",0);
  comargs.outdir="";
  comargs.idonly = false;
  comargs.showjobnum = false;
  comargs.startconfig = "";
  
#ifndef MPI_DISABLED
  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#else
  numprocs = 1;
  rank = 0;
#endif

  addComOption("lsize",       required_argument, NULL,                'L', "define lattice size",                     "xsize:tsize");
  addComOption("nmeas",       required_argument, NULL,                'N', "set number of measurements",              "nmeas");
  addComOption("skip",        required_argument, NULL,                'S', "set number of skips between configs",     "nskip");
  addComOption("nequi",       required_argument, NULL,                'E', "set number of equilibrations",            "nequi");
  addComOption("ocache",      required_argument, NULL,                'O', "set observable cache (mode=oo|ro|wo|rw)", "dir:mode");
  addComOption("ccache",      required_argument, NULL,                'C', "set config cache (mode=oo|ro|wo|rw)",     "dir:mode");
  addComOption("write",       required_argument, NULL,                'W', "data writeout directory",                 "dir");
  addComOption("idonly",      no_argument,       &comargs.idonly,     'I', "show output-id only",                     "");
  addComOption("jobnum",      no_argument,       &comargs.showjobnum, 'J', "show jobnumber only",                     "");
  addComOption("startconfig", required_argument, NULL,                'X', "read start config from file",             "startconfigfile");
  
  vector<comoption>::iterator lastO815Opt = comOptions.end()-1;

  if (specOps != NULL)
    for (int ispecop = 0; specOps[ispecop].name != ""; ispecop++)
      comOptions.push_back(specOps[ispecop]);

  if (argc > 1)
    parseArgs(argc, argv, specOps);
  else {
    int longestCombinedLong=0;
    
    if (helpHeader != NULL)
      helpHeader();

    cout << "General options:" << endl;

    for (vector<comoption>::iterator opit = comOptions.begin(); opit != comOptions.end(); ++opit) {
      stringstream combinedLong;

      combinedLong << opit->name;
      if (opit->has_arg == required_argument)
	combinedLong << "=" << opit->argdesc;
      else if (opit->has_arg == optional_argument)
	combinedLong << "[=" << opit->argdesc << "]";

      if (longestCombinedLong < combinedLong.str().size())
	longestCombinedLong = combinedLong.str().size();
    }

    for (vector<comoption>::iterator opit = comOptions.begin(); opit != comOptions.end(); ++opit) {
      stringstream combinedLong;

      cout << "  -" << char(opit->val) << ", --";

      combinedLong << opit->name;
      if (opit->has_arg == required_argument)
	combinedLong << "=" << opit->argdesc;
      else if (opit->has_arg == optional_argument)
	combinedLong << "[=" << opit->argdesc << "]";

      cout << setw(longestCombinedLong) << setiosflags(ios::left) << combinedLong.str();

      cout << "\t" << opit->optdesc;
      
      cout << endl;

      if ( opit == lastO815Opt && (opit+1) != comOptions.end() ) {
	cout << endl;
	cout << "Simulation specific options:" << endl;
      }
    }
    exit(0);
  }

  paraQ = new paraq(numprocs, rank);

  hypercache::addPara("lx", comargs.lsize[0]);
  hypercache::addPara("lt", comargs.lsize[1]);
}

void o815::postParaInit() {
  long timestamp;

  if(comargs.idonly) {
    cout << programid << headMaster(true) << endl << flush;
    exit(0);
  }

  if( comargs.showjobnum ) {
    for( int i=1; i<=paraQ->getTotalJobs(); i++ ) {
      if( paraQ->getTotalJobs()%i == 0 ) cout << paraQ->getTotalJobs()/i << "@" << i << " ";
    }
    cout << endl;
    exit(0);
  }
  
  out = new writeout(comargs.outdir, programid+headMaster(true), rank, numprocs);
}

void o815::mainLoop() {
  *out->log << "OBS: Starting main loop." << endl;

  if ( observables.size() == 0 )
    *out->log << "O815: Running in 0-observable-mode." << endl;

  for (vector<obs*>::iterator obsit = observables.begin(); obsit != observables.end(); ++obsit)
    (*obsit)->start();

  while( nextParas() ) {
    *out->log << endl << "O815: < ";
    for (vector<string>::iterator parait = paraQ->allParaIds.begin(); parait != paraQ->allParaIds.end(); ++parait)
      *out->log << *parait << "=" << (*paraQ)[*parait] << " ";
    *out->log << ">" << endl << flush;

    Sim->_newParas();

    Sim->resetConfig();
    
    progress measProg(comargs.nmeas);

    *out->log << "OBS: Starting measurement of observables:";
    for (vector<obs*>::iterator obsit = observables.begin(); obsit != observables.end(); ++obsit)
      *out->log << " " << (*obsit)->obsid;
    *out->log << endl << flush;

    for( int imeas=0; imeas<comargs.nmeas; imeas++ ) {
      bool nextAlready = false;

      for (vector<obs*>::iterator obsit = observables.begin(); obsit != observables.end(); ++obsit) {
	bool readnewObs;
	int nequileftNewObs;
	
	hypercache::readO( (*obsit)->ocid, &readnewObs, &nequileftNewObs );

	if ( readnewObs && nequileftNewObs < 0 ) {
	  (*obsit)->meas(true, imeas);
	}
	else {
	  if (!nextAlready) {
	    Sim->nextConfig();
	    nextAlready = true;
	  }
	  (*obsit)->meas(false, imeas);
	  hypercache::writeO( (*obsit)->ocid );
	}	  
      }

      if ( observables.size() == 0 )
	Sim->nextConfig();

      while( measProg.madeStep(imeas) ) 
	*out->log << "O815: " << measProg.done()*100 << "% of measurements done." << endl << flush;
    }
    for (vector<obs*>::iterator obsit = observables.begin(); obsit != observables.end(); ++obsit)
      (*obsit)->finish();
  }
}

void o815::addComOption(const char* name, int has_arg, int *flag, int val, const char* optdesc, const char* argdesc) {
  comoption newop = { name, has_arg, flag, val, optdesc, argdesc };
  comOptions.push_back(newop);
}

void o815::parseArgs(int argc, char **argv, comoption specOps[]) {
  int opt;
  int indexptr=0;
  stringstream optargstr;
  option allOptions[comOptions.size()+1];

  for (int iop=0; iop < comOptions.size(); iop++) {
    allOptions[iop].name = comOptions[iop].name.c_str();
    allOptions[iop].has_arg = comOptions[iop].has_arg;
    //allOptions[iop].flag = NULL;
    allOptions[iop].flag = comOptions[iop].flag;
    allOptions[iop].val = comOptions[iop].val;

    optargstr << char(allOptions[iop].val);
    if (allOptions[iop].has_arg == required_argument)
      optargstr << ":";
    else if (allOptions[iop].has_arg == optional_argument)
      optargstr << "::";
  }

  allOptions[comOptions.size()].name = 0;
  allOptions[comOptions.size()].has_arg = 0;
  allOptions[comOptions.size()].flag = 0;
  allOptions[comOptions.size()].val = 0;

  while((opt = getopt_long( argc, argv, optargstr.str().c_str(), allOptions, &indexptr )) != -1)
    switch(opt) {
    case 'L':
      listArg(comargs.lsize, 2, optarg);
      break;
    case 'N':
      comargs.nmeas = atoi(optarg);
      break;
    case 'S':
      comargs.nskip = atoi(optarg);
      break;
    case 'E':
      comargs.nequi = atoi(optarg);
      break;
    case 'O':
      readCacheArgs(optarg, comargs.obscache.first, comargs.obscache.second);
      break;
    case 'C':
      readCacheArgs(optarg, comargs.confcache.first, comargs.confcache.second);
      break;
    case 'W':
      comargs.outdir = optarg;
      break;
    case 'X':
      comargs.startconfig = optarg;
      break;
    default:
      if ( opt != 0) {
	comoption* thisop = getOptionByVal(opt);
	if (thisop->flag != 0)
	  *thisop->flag = thisop->val;
	else
	  parsedSpecOps.push_back( pair<int,char*>(thisop->val, optarg) );
      }
      break;
    }

  for (int ilon=0; optind+ilon < argc; ilon++)
    lonelyArgs.push_back(argv[optind+ilon]);
}

o815::comoption* o815::getOptionByVal(int val) {
  for (vector<comoption>::iterator opit = comOptions.begin(); opit != comOptions.end(); ++opit)
    if ( opit->val == val )
      return &(*opit);
  exit(1);
}

void o815::listArg(int *target, int tlen, char *listarg) {
  int nargs=0;
  
  for( int pos=0; pos<strlen(listarg); pos++ ) 
    if( listarg[pos] == ':' ) nargs++;
  
  if(nargs==0) 
    for(int i=0; i<tlen; i++) target[i] = atoi(listarg);
  else
    {
      target[0] = atoi(strtok(listarg, ":"));
      for(int i=0; i<nargs; i++)
	target[i+1] = atoi(strtok(NULL, ":"));
    }
}

string o815::headMaster(bool hashedrange)
{
  stringstream hm;
  
  hm << "_L" << comargs.lsize[0] << "x" << comargs.lsize[1] << "_E" << comargs.nequi << "_S" << comargs.nskip << "_N" << comargs.nmeas;

  if( ! hashedrange )
    hm << paraQ->rangeString();
  else
    hm << "_" << hash( paraQ->rangeString() );
  
  return hm.str();
}

o815::~o815() {
  if(comargs.outdir=="") {
#ifndef MPI_DISABLED
    MPI_Barrier(MPI_COMM_WORLD);
#endif
    if(rank==0)
      cout << "#end" << endl << flush;
  }
  hypercache::finalize();
  delete out;
#ifndef MPI_DISABLED
  MPI_Finalize();
#endif
}

int o815::nextParas()
{
  if( paraQ->nextParas() ) {
    for (vector<string>::iterator parait = paraQ->allParaIds.begin(); parait != paraQ->allParaIds.end(); ++parait)
      hypercache::setPara(*parait, (*paraQ)[*parait]);
    return 1;
  }
  else
    return 0;
}

void o815::addPara(const string& paraid, const double& paraDefault) {
  hypercache::addPara(paraid);
  paraQ->setDefault(paraid, paraDefault);
}

void o815::readCacheArgs(const string& arg, string& cachedir, int& cachemode)
{
  if ( arg.rfind(":") == string::npos ) {
    cerr << "O815: Invalid cache argument!" << endl;
    exit(1);
  }

  string arg_mode = arg.substr( arg.rfind(":")+1 );
  if ( arg_mode == "oo" )
    cachemode = CACHE_MODE_OO;
  else if ( arg_mode == "ro" )
    cachemode = CACHE_MODE_RO;
  else if ( arg_mode == "wo" )
    cachemode = CACHE_MODE_WO;
  else if ( arg_mode == "rw" )
    cachemode = CACHE_MODE_RW;
  else {
    cerr << "O815: Unknown cache mode " << arg_mode << "!" << endl;
    exit(1);
  }

  cachedir = arg.substr( 0, arg.rfind(":") );
}

unsigned long o815::hash(const string& str)
{
  unsigned long hash = 5381;

  for(string::const_iterator it=str.begin();it!=str.end();it++) 
    hash = ((hash << 5) + hash) + *it; /* hash * 33 + character */

  return hash;
}