//
//  sector.cpp
//  PSPA
//
//  Created by Garnier Laurent on 10/12/13.
//  Copyright (c) 2013 Garnier Laurent. All rights reserved.
//

#include "sector.h"

//#include "sectionToExecute.h"
#include "dataManager.h"
#include "elementDrift.h"
#include "elementRfgun.h"
#include "elementCell.h"
#include "elementSoleno.h"
#include "elementBend.h"
#include "elementBeam.h"
#include "elementFit.h"
#include "elementSnapshot.h"
#include "elementMultipole.h"
#include "elementQuadrupole.h"
#include "elementSextupole.h"

sector::sector(dataManager* data, std::string name):
reflected_(false),
duplicatedFrom_(NULL),
repetitionNumber_(1),
currentBeam_(NULL),
name_(name),
dataManager_(data),
sectorParam_(this)
{
  
}

sector::~sector()  {
}

abstractElement* sector::addElementAfter(nomdElements::typedElement eType ,abstractElement* previousElement)
{

  // create a new abstractElement
  // FIXME : To be move in an abstractFactory in the controler !!
  abstractElement* currentElement = NULL;
  switch (  eType ) 
    {
    case nomdElements::RFgun :
      currentElement = new elementRfgun();
      break;
    case nomdElements::drift :
      currentElement = new elementDrift();
      break;
    case nomdElements::cell  :
      currentElement = new elementCell();
      break;
    case nomdElements::bend  :
      currentElement = new elementBend();
      break;
    case nomdElements::soleno  :
      currentElement = new elementSoleno();
      break;
    case nomdElements::beam  :
      currentElement = new elementBeam();
      break;
    case nomdElements::fit  :
      currentElement = new elementFit();
      break;
    case nomdElements::mpole  :
      currentElement = new elementMultipole();
      break;
    case nomdElements::qpole  :
      currentElement = new elementQuadrupole();
      break;
    case nomdElements::spole  :
      currentElement = new elementSextupole();
      break;
    case nomdElements::snapshot :
      {
	// FIXME : Snapshot a gérér
	/*        int incr = dataManager_->getPspaApplication()->getExtensionFile();
		  incr++;
		  dataManager_->getPspaApplication()->setExtensionFile(incr);
	*/
	currentElement = new elementSnapshot();
	break;
      }
    }

  if (!currentElement) {
    return NULL;
  }
  addElementAfter(currentElement,previousElement);
  return currentElement; 
}


void sector::addElementAfter(abstractElement* currentElement ,abstractElement* previousElement){
// if the previous element is NULL, it will try to add at the beginning of the first section
  
  if (previousElement == NULL) {
    elements_.insert ( elements_.begin() ,currentElement);
    // if (sectionToExecute_.size() == 0) {
    //   sectionToExecute_.push_back(new sectionToExecute(currentElement,NULL,dataManager_,this));
    // } else {
    //     sectionToExecute* section = sectionToExecute_.front();
    //   section->insertAtFirst(currentElement);
    // }
  } else {
    insertAfter(previousElement,currentElement);
    // for (unsigned int i=0; i<sectionToExecute_.size(); i++) {
    //   sectionToExecute* section = sectionToExecute_[i];
    //   if (section->insertAfter(previousElement,currentElement)) {
    //     return;
    //   }
    // }
  }
}


bool sector::insertAfter(abstractElement* previousElement,abstractElement* currentElement) {

  std::vector<abstractElement*>::iterator it;
  for (it = elements_.begin(); it < elements_.end(); it++) {
    if (*it == previousElement ) {
      elements_.insert (it+1,currentElement);
      return true;
    }
  }
  return false;
}

bool sector::isInside(abstractElement* previousElement) {
  for (unsigned int a=0; a< elements_.size(); a++) {
    if (elements_[a] == previousElement ) {
      return true;
    }
  }
  return false;
}



void sector::removeElement(abstractElement* currentElement) {
  if (currentElement == NULL) return;
  std::vector<abstractElement*>::iterator it;
  for (it = elements_.begin(); it < elements_.end(); it++) {
    if (*it == currentElement ) {
      elements_.erase(it);
      return;
    }
  }
  // for (unsigned int i=0; i<sectionToExecute_.size(); i++) {
  //   sectionToExecute* section = sectionToExecute_[i];
    
  //   if (section->isInside(currentElement)) {
  //     section->removeElement(currentElement);
  //   }
  // }
}


// void sector::clearSectionToExecute()
// {
//   unsigned k;
//   for(k = 0; k < sectionToExecute_.size(); k++)
//   {
//     if ( sectionToExecute_[k] != NULL ) clearSectionToExecute(k);
//   }
//   sectionToExecute_.clear();
// }

// void sector::clearSectionToExecute(int a)
// {
//   cout << " dataManager::clearSectionToExecute : effacement de la section d'index = " << a << endl;
//   if (a < 0) return;
//   if (a >= (int)sectionToExecute_.size()) return;
  
//   // lors de la creation de la section on a fait un 'new' d'un
//   // softwareXXXX : on fait ici le 'delete'
  
//   const abstractSoftware* soft = sectionToExecute_.at(a)->getSoftware();
//   if ( soft != NULL ) delete soft;
//   delete sectionToExecute_[a];
//   sectionToExecute_.erase (sectionToExecute_.begin()+a);
// }