#include "hypercache.h"

#include <cstdlib>
#include <cstring>

configcache *hypercache::C = NULL;
vector<hypercache::para> hypercache::delayedParaAdd;
vector<hypercache::para> hypercache::delayedParaSet;
string hypercache::activeCFile = "";
vector<unsigned long> hypercache::parentConfigs;
ostream* hypercache::log;
vector<hypercache::observable> hypercache::Os;
int hypercache::NEQUI;
int hypercache::NSKIP;
int hypercache::nequileft;
pair<int, char*> hypercache::mostEquilibratedConfig;

void hypercache::initCache(configcache **cache,
			   const string& cacheid, const int& nequi, const int& nskip, const string& datadir, 
			   char **configmem, const int& configMemSize, const int& cachemode, ostream* _log) {
  if ( _log != NULL )
    log = _log;
  
  *cache = new configcache(cacheid, nequi, nskip, datadir, configmem, configMemSize, cachemode, log);
  
  for (vector<para>::iterator parit=delayedParaAdd.begin(); parit != delayedParaAdd.end(); ++parit)
    (*cache)->addPara(parit->parid, parit->val);

  for (vector<para>::iterator parit=delayedParaSet.begin(); parit != delayedParaSet.end(); ++parit)
    (*cache)->setPara(parit->parid, parit->val);

  NEQUI = nequi;
  NSKIP = nskip;
}

void hypercache::addPara(const string& parid, const double& val) {
  para newpara; 
  newpara.parid = parid;
  newpara.val = val;
  delayedParaAdd.push_back(newpara);

  if (C != NULL)
    C->addPara(parid, val);

  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
    osit->c->addPara(parid, val);
}

void hypercache::setPara(const string& parid, const double& val) {
  para newpara; 
  newpara.parid = parid;
  newpara.val = val;
  delayedParaSet.push_back(newpara);

  if (C != NULL)
    C->setPara(parid, val);
  
  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
    osit->c->setPara(parid, val);

  nequileft = NEQUI;
  mostEquilibratedConfig.first = NEQUI;
}

void hypercache::finalize() {
  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
    delete osit->c;
  
  delete C;
}

string hypercache::fileOfPath(const string& dressedfile) {
  return dressedfile.substr(dressedfile.find_last_of("\\/")+1);
}

bool hypercache::readC() {
  bool readAtLeastOneConfig;

  C->readConfig(&readAtLeastOneConfig, &nequileft, &parentConfigs);

  if ( nequileft < 0 && readAtLeastOneConfig )
    activeCFile = fileOfPath(C->getInFileName());
  else
    activeCFile = "";

  /* try to find more equilibrated config-file configuration for equilibration in excluded files */
  if ( ( nequileft >= 0 || ( ! readAtLeastOneConfig ) ) && C->inFilesLeft() > 0 ) {
    int nEquiLeftBeforeExcludedFileCheck = nequileft;
    *log << "HYPERCACHE: Trying to find more equilibrated config in excluded files." << endl << flush;

    char *tmpconfig = (char*) malloc(C->getConfigSize());

    while (true) {
      bool readnewconfig_ex;
      int nequileftReadConfig_ex;

      memcpy (tmpconfig, C->getConfigMem(), C->getConfigSize());
      C->readConfig(&readnewconfig_ex, &nequileftReadConfig_ex, NULL);

      if (! readnewconfig_ex) {
	*log << "HYPERCACHE: No more excluded config-files for possible equilibration available." << endl << flush;
	break;
      }
      
      if (nequileftReadConfig_ex <= nequileft) {
	nequileft = nequileftReadConfig_ex;
	readAtLeastOneConfig = false;
      }
      else if (nequileftReadConfig_ex > nequileft) {
	memcpy (C->getConfigMem(), tmpconfig, C->getConfigSize());
      }
    }
    free(tmpconfig);

    if (nEquiLeftBeforeExcludedFileCheck > nequileft)
      *log << "HYPERCACHE: Found more equilibrated or same equilibrated excluded config-file configuration for equilibration." << endl << flush;
    else
      *log << "HYPERCACHE: Excluded config-file configuration for equilibration is less equilibrated than actual config." << endl << flush;
  }

  /* storing most equilibrated config */
  if ( nequileft < mostEquilibratedConfig.first && readAtLeastOneConfig ) {
    mostEquilibratedConfig.first = nequileft;
    memcpy(mostEquilibratedConfig.second, C->getConfigMem(), C->getConfigSize());
  }

  /* injecting back most equilibrated config if nothing could be used anymore */
  if ( (!readAtLeastOneConfig) && mostEquilibratedConfig.first < nequileft ) {
    *log << "HYPERCACHE: Injecting back most equilibrated stored config with nequileft = " << mostEquilibratedConfig.first << endl << flush;
    nequileft = mostEquilibratedConfig.first;
    memcpy(C->getConfigMem(), mostEquilibratedConfig.second, C->getConfigSize());
  }

  return readAtLeastOneConfig;
}

void hypercache::writeC() {
  if (nequileft > 0)
    nequileft = 0;

   nequileft -= NSKIP;

  C->writeConfig(NEQUI-nequileft-NSKIP);
  activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
}

void hypercache::writeO(int obsid) {
  if ( ( Os[obsid].lastWrittenObsEquis + NSKIP != NEQUI-nequileft-NSKIP ) && Os[obsid].c->isOutFileOpen() )
    Os[obsid].c->finishOutFile();

  if ( activeCFile != "" ) {
    unsigned long afilehash = configcache::hash(activeCFile);
    Os[obsid].c->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long), NEQUI-nequileft-NSKIP);
  }
  Os[obsid].c->writeConfig(NEQUI-nequileft-NSKIP); 

  Os[obsid].lastWrittenObsEquis = NEQUI-nequileft-NSKIP;
}

void hypercache::readO(int obsid, bool *readNewObsConfig, int *nequiObsLeft) {
  Os[obsid].c->readConfig(readNewObsConfig, nequiObsLeft);

  if ( *readNewObsConfig && *nequiObsLeft < 0 ) {
    unsigned long *parentconfig = (unsigned long*)Os[obsid].c->getHeader("concurrent_cfile");
    if ( parentconfig != NULL )
      addParentConfig(parentconfig);
  }
}

void hypercache::addParentConfig(const unsigned long *parentconfig) {
  for (vector<unsigned long>::iterator parit = parentConfigs.begin(); parit != parentConfigs.end(); ++parit)
    if ( *parit == *parentconfig )
      return;

  parentConfigs.push_back(*parentconfig);
}