#include "dataManager.h"
#include "environmentVariables.h"
#include "transportMoments.h"

#include <stdio.h>
#include <fstream>

abstractElement* dataManager::addElement(typedElement elemType)
{
  return elementsGallery_.addElement(elemType);
}

string dataManager::getLabelFromElementNumero(int numero)
{
  abstractElement* ptr = elementsGallery_.getElementPointerFromNumero(numero);
  if ( ptr == NULL ) return "";
  return ptr->getLabel();
}


void dataManager::addSectionToExecute(int debut, int fin, nomDeLogiciel prog)
{
  jobList_.push_back(new sectionToExecute);
  jobList_.back()->firstElement = debut;
  jobList_.back()->lastElement = fin;
  jobList_.back()->software  = prog;
}

void dataManager::clearSectionToExecute()
{
  unsigned k;
  for(k = 0; k < jobList_.size(); k++)
    {
      if ( jobList_[k] != NULL ) delete jobList_[k];
    }
  jobList_.clear();
}

string dataManager::checkExecute()
{
  cout << "dataManager::checkExecute()" << endl;
  
  int k,j;
  string diagnostic;
  int indexDeb, indexFin;
  cout << "controle execution : " << endl;
  for(k = 0; k < jobList_.size(); k++) {
    indexDeb = jobList_[k]->firstElement;
    indexFin = jobList_[k]->lastElement;
    if ( indexFin  <= indexDeb )
      {
	diagnostic += " first ans last elements are the same \n";
	break;
      }
    cout << " indexDeb= " << indexDeb << " indexFin= " << indexFin << endl;
    indexDeb--;
    indexFin--;
    abstractElement* elPtr;
    if(jobList_[k]->software == nomDeLogiciel::parmela ) 
      {
	for(j = indexDeb; j <= indexFin; j++) {
	  elPtr = elementsGallery_.getElementPointer(j);

	  cout << "elPtr parmela: " << elPtr->getLabel() << endl;

	  if(!elPtr->is_parmela_element()) {
	    diagnostic += " the element " + elPtr->getName().getElementName() + " is not allowed for PARMELA \n";
	  }
	}	    
      }
    else if (jobList_[k]->software == nomDeLogiciel::transport) 
      {
	for(j = indexDeb; j <= indexFin; j++) {
	  elPtr = elementsGallery_.getElementPointer(j);

	  cout << "elPtr transp: " << elPtr->getLabel() << endl;

	  if (!elPtr->is_transport_element()) {
	    diagnostic += " the element " + elPtr->getName().getElementName() + " is not allowed for TRANSPORT \n";
	  }
	}	    
      }
    else 
      {
	diagnostic += (jobList_[k]->software).getString() + " : unknown software \n ";	
      }
  }
  
  return diagnostic;
}

bool dataManager::executeTransport( unsigned int indexDeb, unsigned int indexFin, string& resul)
{
  ostringstream sortie;
  bool success = true;
  resul.clear();
  sortie << " EXECUTION DE TRANSPORT DE " << indexDeb << " a " << indexFin << endl;
  if ( !createInputFileTransport( indexDeb, indexFin) )
    {
      sortie << " error creating transport input file "  << endl;
      resul = sortie.str();
      success = false;
      return success;
    }

  string bufString;
  char buf[132];
  string transportJob = WORKINGAREA + "transport";
  transportJob += string(" <  ");
  transportJob += WORKINGAREA + "transport.input";
  //  transportJob += string(" >  ");
  //  transportJob += WORKINGAREA + "transport.output";
  cout << " job transport= " << transportJob << endl;

  ofstream outfile;
  string nameOut = WORKINGAREA + "transport.output";


  FILE* pp = popen(transportJob.c_str(), "r");
  if (pp != NULL)
    {
      cout << " execution transport MARCHE " << endl;

      ////////////////////////
      outfile.open(nameOut.c_str(), ios::out);
      if (!outfile) 
      	{
      	  sortie << " error first opening transport output stream " << nameOut << endl;
	  resul = sortie.str();
	  success = false;
	  return success;
      	}

      unsigned nbl = 0;
      while (fgets(buf, sizeof buf, pp))
	{
	  //	  cout << " buf= " << buf << endl;
	  sortie << buf;
	  outfile << buf;
      	  nbl++;
	}
      outfile.close();
      /////////////////////////////////

      //      cout << " datamanager ecriture output terminee nbl = " << nbl << endl;
      // on re-ouvre le fichier de sortie

      ifstream infile;

      infile.open(nameOut.c_str(), ios::in);
      
      //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

      int k;
      for ( k= indexDeb; k <= indexFin; k++)
	{
	  diagnosticBeam_.push_back(particleBeam());

	  string elemLabel = getLabelFromElementNumero (k);
	  abstractElement* ptr = elementsGallery_.getElementPointerFromNumero(k);
	  bool camarche = diagnosticBeam_.back().setFromTransport(elemLabel, ptr->getName() );
	  if (!camarche  )
	    {
	      sortie << " reading transport output  failed " << endl;
	      success = false;
	      break;
	    }
	}
      currentBeam_ = &diagnosticBeam_.back();
      //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

      pclose(pp);
      resul =  sortie.str();
    }
  else
    {
      sortie << " launching of transport failed \n";
      resul =  sortie.str();
      success =  false;
    }
  return success;
}

bool  dataManager::executeParmela(unsigned int indexDeb,unsigned int indexFin,string& resul)
{
  bool success = true;
  resul.clear();
  createInputFileParmela(indexDeb,indexFin);

  ostringstream sortie;
  sortie << " EXECUTION DE PARMELA DE l'ELEMENT " << indexDeb << " A L'ELEMENT " << indexFin << endl;

  char buf[132];
  string parmelaJob = WORKINGAREA + "parmela";
  parmelaJob += string("   ");
  parmelaJob += WORKINGAREA;
  cout << " job parmela= " << parmelaJob << endl;
  FILE* pp = popen(parmelaJob.c_str(), "r");
  if (pp != NULL) {
    cout << " execution parmela MARCHE " << endl;
    while (fgets(buf, sizeof buf, pp))
      {
	sortie << buf;
      }

    //      cout << " sortie parmela " << sortie.str() << endl;
    string::size_type nn = (sortie.str()).find("normal");
    if ( nn == string::npos ) 
      {
	sortie << " abnormal exit of parmela " << endl;
	resul =  sortie.str();
	success = false;
	return success;
      }

    int k;
    for ( k= indexDeb; k <= indexFin; k++)
      {
	diagnosticBeam_.push_back(particleBeam());
	if (! diagnosticBeam_.back().setFromParmela(k, globParam_.getFrequency()) )
	  {
	    sortie << " reading parmdesz  failed " << endl;
	    success = false;
	    break;
	  }
      }
    currentBeam_ = &diagnosticBeam_.back();

    // if ( !currentBeam_->setFromParmela(indexFin, globParam_.getFrequency()) )
    // 	{
    // 	  sortie << " reading parmdesz  failed " << endl;
    // 	  success = false;
    // 	}
    pclose(pp);
    resul =  sortie.str();
  }
  else
    {
      sortie << " launching of parmela failed " << endl;
      resul =  sortie.str();
      success = false;
    }
  
  return success;
}

bool dataManager::createInputFileTransport( unsigned int numeroDeb, unsigned int numeroFin)
{
  unsigned int k;
  unsigned indexDeb = numeroDeb - 1;
  unsigned indexFin = numeroFin - 1;
  if ( indexDeb < 0 || indexFin >= elementsGallery_.size() ) {
    cerr << " index of element out of limits " << endl;
    return false;
  }

  abstractElement* premierEl = NULL;
  premierEl = elementsGallery_.getElementPointer(indexDeb);

  // ceinture et bretelles
  if ( premierEl == NULL ) {
    cerr << " premier element inexistant ?? " << endl;
    return false;
  }


  ofstream outfile;
  string name = WORKINGAREA + "transport.input";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) 
    {
      cerr << " error opening output stream " << name << endl;
      return false;
    }

  outfile << string("'titre provisoire'") << endl;
  outfile << " 0 " << endl;
  outfile << " UTRANS " << endl;


  // si le premier element a traiter est un 'beam', on ne fait rien pour l'instant
  // il sera traite plus bas de maniere standard

  // Dans le cas où le premier element n'est pas beam
  if ( premierEl->getName().getElementType() != beam ) {
    // s'il n'y a pas faisceau courant, erreur
    if ( currentBeam_ == NULL ) {
      cout << " pas de faisceau " << endl;
      return false;
    }
    else {
      // s'il y a un faisceau courant
      if ( !currentBeam_->momentRepresentationOk() ) {
	// s'il n'est pas au format transport (issu de parmela ?)
	// on le met au format transport, s'il est deja au format 'particules' (par ex/ parmela)
	if ( !currentBeam_->particleRepresentationOk() ) {
	  cout << " ca cafouille dans les representations de faisceau : ni particules, ni moments ? " << endl;
	  return false;
	}
	else {
	  currentBeam_->buildMomentRepresentation();
	}
      }
      // ici, en principe, on a un faisceau correct
      // on ecrit sur le fichier input
      const transportMoments& moments = currentBeam_->getTransportMoments();
      double P0 = currentBeam_->getP0Transport();
      outfile << moments.writeToTransportInput(P0);
    }
  }



  outfile << " PRINT, BEAM, ON; " << endl;


  abstractElement* elPtr;
  for ( k=indexDeb; k <= indexFin; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->transportOutputFlow() << endl;
    }

  outfile << " SENTINEL " << endl;
  outfile << " SENTINEL " << endl;

  outfile.close();
  return true;
}

void dataManager::createInputFileParmela( unsigned int indexDeb, unsigned int indexFin)
{
  indexDeb--;
  indexFin--;

  ofstream outfile;
  string name = WORKINGAREA + "parmin";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
    cerr << " error opening output stream " << name << endl;
  }

  abstractElement* elPtr;
  elPtr = elementsGallery_.getElementPointer(indexDeb);
  if ( elPtr->getName().getElementType() != RFgun ) {
    cerr << " dataManager::createInputFileParmela : the first element should be rfgun" << endl;
  }
  
  unsigned int k;
  double initalKineticEnergy = 0.0;
  for ( k = indexDeb; k <= indexFin; k++)
    {
      if ( elPtr->getName().getElementType() == RFgun ) 
	{
	  elPtr->setPhaseStep( globParam_.getIntegrationStep() );
	  elPtr = elementsGallery_.getElementPointer(k);
	  initalKineticEnergy = elPtr->getInitialKineticEnergy();
	  break;
	}
    }

  outfile << "TITLE" << endl;
  outfile << " titre provisoire " << endl;
  outfile << "RUN /n0=1 /ip=999 /freq=" << globParam_.getFrequency() << "  /z0=0.0 /W0=" << initalKineticEnergy << "  /itype=1" << endl;
  outfile << "OUTPUT 0" << endl;
    
  for ( k = indexDeb; k <= indexFin; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->parmelaOutputFlow() << endl;
    }

  outfile << "ZOUT" << endl;
  outfile << "START /wt=0.0 /dwt=" << globParam_.getIntegrationStep() << "  /nsteps=" << globParam_.getNbSteps() << "  nsc=" << globParam_.getScPeriod() << "  /nout=10" << endl;
  outfile << "END" << endl;
  outfile.close();
}

void dataManager::initializeExecution()
{
  removeFile("parmdesz");
  removeFile("parmin");
  removeFile("transport.input");
  removeFile("transport.output");
  diagnosticBeam_.clear();
  currentBeam_ = NULL;
  clearSectionToExecute();
}

void dataManager::removeFile(string nameOfFile) 
{
  ifstream fileExists;
  string completeName = WORKINGAREA + nameOfFile;
  fileExists.open(completeName.c_str(), ios::in);
  if (fileExists) {
    fileExists.close();
    remove(completeName.c_str());
  }
}

bool dataManager::executeAll(string &resul)
{
  bool success = true;
  resul.clear();
  string resultatPartiel;
  unsigned k;
  for(k = 0; k < jobList_.size(); k++)
    {
      int debut = jobList_[k]->firstElement;
      int fin = jobList_[k]->lastElement;
      resultatPartiel.clear();
      cout << " dataManager::executeAll je m'apprete a executer : " << (jobList_[k]->software).getString() << endl;

      if(jobList_[k]->software == nomDeLogiciel::parmela) {
	success = executeParmela( debut, fin, resultatPartiel);
      } else if (jobList_[k]->software == nomDeLogiciel::transport) {
	success = executeTransport( debut, fin, resultatPartiel);
      } else {
	success = false;
	resultatPartiel =  " unknown software -- STOP \n ";	
	break;
      }
      resul += resultatPartiel;
      if ( !success ) break;
    }
  return success;
}

void dataManager::saveConfiguration(string nameOfFile)
{
  ofstream outfile;
  string name = WORKINGAREA + nameOfFile + ".save";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
    cerr << " error opening output file for persistency " << name << endl;
  }

  outfile << globParam_.FileOutputFlow();
  int k;
  abstractElement* elPtr;
  for ( k=0 ; k < elementsGallery_.size() ; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->FileOutputFlow();
    }
  outfile.close();    
}

void dataManager::restoreElements(string inputFileName)
{
  cout << "dataManager::restoreElements()" << endl;
      
  ifstream infile;
  //  string name = WORKINGAREA + "pspa.save";
  infile.open(inputFileName.c_str(), ios::in);
  if (!infile) {
    cerr << " error opening input stream " << inputFileName << endl;
  }
  else cout << " successful opening input stream " << inputFileName << endl;

  int ielem;
  string globalTitle;
  if ( infile >> globalTitle ) {
    if ( globalTitle == string("globals") ) {
      globParam_.raz();
      globParam_.FileInput(infile);
    } else {
      cerr << " dataManager::restoreAll ERROR : global parameters seems to be missing" << endl;
    }
  } else {
    cerr << " dataManager::restoreAll ERROR : reading data save file" << endl;
  }

  elementsGallery_.raz();
  //  typedElement elem;
 typedElement elementType;
  string elementLabel;
  //  while (infile >> ielem) {
  while (infile >> elementLabel) {
    //    elem = (typedElement)ielem;
    //    abstractElement* nouveau = addElement(elem);
    elementType = nomdElements::getTypeFromLabel(elementLabel);
    abstractElement* nouveau = addElement( elementType);
    nouveau->FileInput(infile);
  }  
  infile.close();

  // debug
  int k;
  for(k = 0; k <  elementsGallery_.size(); k++) {
    abstractElement* ptr= elementsGallery_.getElementPointer(k);
    cout << "reupere " << ptr->getLabel() << endl;
  }
}

particleBeam* dataManager::getDiagnosticBeam(int index) 
{
  cout << " particleBeam* dataManager je vais dessiner " << getLabelFromElementNumero(index+1) << endl;
  return &diagnosticBeam_.at(index);
}

void dataManager::donneesRmsEnveloppe( string type, unsigned int numeroDeb, unsigned int numeroFin, vector<double>& xcor, vector<double>& ycor)
{
  unsigned k;
  unsigned indexDeb = numeroDeb -1;
  unsigned indexFin = numeroFin -1;
  double longueur = 0.0;
  double valeur = 0.0;
  xcor.clear();
  ycor.clear();
  if ( type == "x" )
    {
      for (k= indexDeb; k <= indexFin; k++)
	{
	  if ( !diagnosticBeam_.at(k).momentRepresentationOk() ) diagnosticBeam_.at(k).buildMomentRepresentation();
	  longueur += elementsGallery_.getElementPointer(k)->getLenghtOfElement();
	  valeur = diagnosticBeam_.at(k).getXmaxRms();
	  xcor.push_back(longueur);
	  ycor.push_back(valeur);
	}
    }
  else
    {
      cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
      return;
    }
}