#include "computingBlock.h"
#include "mixedTools.h"
 #include "softwareUnknown.h"
#include "expandedMachine.h"


computingBlock::computingBlock(unsigned premier, unsigned nombre, abstractSoftware* s,expandedMachine* mch)  {
  // dataManager_ = dtmg;
  machine_ = mch;
  if ( premier >= machine_->numberOfElements() ) {
    rankOfFirstElement_ = 0;
    numberOfelements_ = 0;
  } else {
    rankOfFirstElement_ = premier;
    if ( nombre < machine_->numberOfElements() - rankOfFirstElement_ +1 ) {
      numberOfelements_ = nombre;
    } else numberOfelements_ = machine_->numberOfElements() - rankOfFirstElement_ +1;
  }
  if (s == NULL) {
    software_ = new softwareUnknown();
  } else {
    software_ = s;
  }
}


void computingBlock::FileAMLOutput(UAPNode* root)
{
  UAPNode* node = root->addChild("computingBlock");
  node->addChild("software")->addAttribute("name",software_->getName());
  unsigned noElem = rankOfFirstElement_;
  UAPNode* blocNode = node->addChild("blocExtension");
  blocNode->addAttribute("rankOfFirstElement",mixedTools::intToString(int(rankOfFirstElement_)));
  blocNode->addAttribute("numberOfelements",mixedTools::intToString(int(numberOfelements_)));
}


void computingBlock::FileAMLInput( UAPNode* entree) {
      string soft;
      AMLtools::readAMLParameterAttribut(entree, "software", "name", soft);
      software_ = machine_->getSoftwarePointer(soft, this);
      int premier, nombre;
      AMLtools::readAMLParameterAttribut(entree, "blocExtension", "rankOfFirstElement", premier);
      AMLtools::readAMLParameterAttribut(entree, "blocExtension", "numberOfelements", nombre);
      rankOfFirstElement_  = premier;
      numberOfelements_ = nombre;
      if ( !checkCompatibilityWithMachine() ) {
	rankOfFirstElement_  = 0;
	numberOfelements_ = 0;
	cout << " computingBlock::FileAMLInput ERREUR lecture " << endl;
      }
}
bool computingBlock::checkCompatibilityWithMachine() {
  if ( !machine_ ) return false;
  if ( rankOfFirstElement_ > machine_->numberOfElements() ) return false;
  if ( numberOfelements_ > machine_->numberOfElements() - rankOfFirstElement_ + 1 ) return false;
  return true;
}
bool computingBlock::checkCoherence(string& diagnosticErrors, string& diagnosticWarnings) {

  cout << " computingBlock::checkCoherence() " << endl;
  bool caMarche = true;

  const nomDeLogiciel* prog = software_->getNomDeLogiciel();

  for(unsigned k =0 ; k < numberOfelements_; k++)
    {
      abstractElement* elem = machine_->getElementPointer(rankOfFirstElement_ + k);
      trivaluedBool tb = prog->doAcceptElement(elem->getNomdElement().getElementType());
      cout << " GWt_softwarePanel::areDataCoherent() el " << elem->getLabel() << " tb= " << tb << endl;
      if (tb  != TBoolOk ) {
	if (tb == TBoolIgnore) {
	  if(prog->getString() != "unknownSoftware") diagnosticWarnings += elem->getLabel() + " will be ignored by  "+ prog->getString() + "<br /> ";
	  cout << " element " <<  elem->getLabel() << " ignore " << endl;
	} else {
	  diagnosticErrors += elem->getNomdElement().getExpandedName() + " is not allowed with " + prog->getString() + "<br /> ";
	  cout << " element " <<  elem->getLabel() << " REFUSE " << endl;
	  caMarche = false;
	}
      }
    } //k
  return caMarche;
}


//   vector< abstractElement* > computingBlock::getElements()  { 
//     vector< abstractElement* > elems;
//     for (unsigned k=0; k < numberOfelements_; k++ ) {
//       elems.push_back( machine_->getElementPointer( rankOfFirstElement_ + k));
//     }
//     return elems;
//   }

abstractElement* computingBlock::getFirstElement() {
  return machine_->getElementPointer( rankOfFirstElement_);
}



abstractElement*  computingBlock::getLastElement() {
  cout << " computingBlock::getLastElement() premier " << machine_->getElementPointer( rankOfFirstElement_)->getLabel() << endl;
  cout << "  nb elements : " << numberOfelements_ << endl;
  cout << " computingBlock::getLastElement() dernier " << machine_->getElementPointer( rankOfFirstElement_ + numberOfelements_ - 1)->getLabel() << endl;
  return machine_->getElementPointer( rankOfFirstElement_ + numberOfelements_ - 1);
}


 abstractElement* computingBlock::getElement(unsigned ind) { return machine_->getElementPointer( rankOfFirstElement_ + ind); }