#include <iostream>
#include <algorithm>    // std::find

#include "abstractElement.h"

abstractElement::abstractElement() 
: abstractSoftware_(NULL)
{
  setDefaultValues();
  setDefaults();
  stepmaxcm_ = 1000000;
}

abstractElement::abstractElement(string lab)
{
  label_ = lab;
  setDefaultValues();
  setDefaults();
  stepmaxcm_ = 1000000;
}

abstractElement::~abstractElement() 
{
  if (parametersString_ != NULL) delete [] parametersString_ ;
}

void abstractElement::setDefaultValues() 
{
  defaultLabel_ = string("XXXXXX");
  defaultLength_ = 0.0;
  defaultAperture_ = 1.e+6;
  phaseStepMax_ = 10.;
}

void abstractElement::setDefaults() 
{
  label_ = defaultLabel_;
  nbParam_ = 2;
  lenghtElem_ = defaultLength_;
  aperture_ = defaultAperture_;
}

void abstractElement::setPhaseStep(double) { 
  cout << " setPhaseStep : ce n'est pas celui la qu'il faut ! " ; 
  return;
}

void abstractElement::setParameters(double ll, double aper) 
{
  lenghtElem_ = ll;
  aperture_ = aper;
}

void abstractElement::setLabel(string lab)
{
  label_= lab;
}

string abstractElement::getLabel() const
{
  return label_;
}


nomdElements abstractElement::getNomdElement() const 
{
  return elementName_;
}



double abstractElement::getLenghtOfElement() const { 
  return lenghtElem_;
}

int abstractElement::getNbParams() const {
  return nbParam_;
}


trivaluedBool abstractElement::is_accepted_by_software(nomDeLogiciel prog) {
    if (acceptableSoftware_.size() == 0) {
        return TBoolError;
    }

    if ( std::find(acceptableSoftware_.begin(), acceptableSoftware_.end(), prog) != acceptableSoftware_.end()) {
        return TBoolOk;
    } else if ( std::find(ignoreSoftware_.begin(), ignoreSoftware_.end(), prog) != ignoreSoftware_.end()) {
        return TBoolIgnore;
    } else {
        return TBoolError;
    }

    return TBoolOk;
}


double abstractElement::getInitialKineticEnergy() const {
  return 0.0;
}


string abstractElement::generatorOutputFlow() const {
  return "";
}

trivaluedBool abstractElement::setSoftware(nomDeLogiciel prog) 
{
  trivaluedBool tb = TBoolError;
  if (std::find(acceptableSoftware_.begin(),acceptableSoftware_.end(),prog) != acceptableSoftware_.end()) {
    tb = TBoolOk;
  } else if (std::find(ignoreSoftware_.begin(),ignoreSoftware_.end(),prog) != ignoreSoftware_.end()) {
    tb = TBoolIgnore;
  } else {
    tb = TBoolError;
  }
  
  if (prog == nomDeLogiciel::unknownSoftware){
    tb = TBoolOk;
  }
    
          if ((tb == TBoolOk) || (tb == TBoolIgnore)) {
    if (prog == nomDeLogiciel::parmela) {
      abstractSoftware_ = new softwareParmela();
    } else if (prog == nomDeLogiciel::transport) {
      abstractSoftware_ = new softwareTransport();
    } else if (prog == nomDeLogiciel::generator) {
      abstractSoftware_ = new softwareGenerator();
    } else if (prog == nomDeLogiciel::test) {
      abstractSoftware_ = new softwareTest();
    } else if (prog == nomDeLogiciel::unknownSoftware) {
      abstractSoftware_ = NULL;
    }
  }
  return tb;
}

void abstractElement::registerAcceptableSoftware(nomDeLogiciel abs,trivaluedBool b) {
  if (b == TBoolIgnore) {
    ignoreSoftware_.push_back(abs);
  } else if (b == TBoolOk) {
    acceptableSoftware_.push_back(abs);
  }
}