/*
 * GetMavenStaticEnergy.hh
 *
 *  Created on: Sep 23, 2015
 *      Author: AKKA
 */

#ifndef GetMavenStaticEnergy_HH_
#define GetMavenStaticEnergy_HH_

#include "vector"

#include <boost/algorithm/string.hpp>

#include <boost/lexical_cast.hpp>

#include "AMDA_exception.hh"
#include "DicError.hh"

#include "Parameter.hh"
#include "ParamData.hh"
#include "Operation.hh"

using namespace std;
using namespace boost;
using namespace AMDA::Parameters;

namespace AMDA {
namespace MavenStatic {

namespace Base {
/**
 * @class Base::GetMavenStaticEnergy
 * @brief Compute Maven STATIC energy
 */
		class GetMavenStaticEnergy : public Operation {
		public:

			/**
			 * @brief Default Constructor.
			 */
			GetMavenStaticEnergy(Process& pProcess) : Operation(pProcess) {}

			/**
			 * @brief Destructor.
			 */
			virtual ~GetMavenStaticEnergy() {}

			/**
			 * @brief initialize the operation .
			 * @detail initialize the operation with information stored in pInput.getInfoList() and pAttribute.
			 */
			virtual void init(Parameter& input, Process::AttributeList& pAttribute)	= 0;

		protected:
		};
	}


/**
 * @class GetMavenStaticEnergy
 * @brief Compute Maven STATIC energy.
 */
template<class TParamData>
class GetMavenStaticEnergy : public Base::GetMavenStaticEnergy {
public:
	/**
	 * @brief Constructor.
	 * @details Create the ParamData type of the input ParamData.
	 */
	GetMavenStaticEnergy(Process& pProcess, TParamData& paramInput)
	: Base::GetMavenStaticEnergy(pProcess), _paramInput(paramInput), _paramOutput(new ParamDataTab1DDouble()) {
	  _paramDataOutput=_paramOutput;
	  }

  /**
   *
	 * @overload Base::GetMavenStaticEnergy::init()
   */

  void init(Parameter& pInput, Process::AttributeList& pAttribute) {

	  Parameter::InfoList& lInfoList = pInput.getInfoList();

	  int nbMass   = (*lInfoList["nmass"].get())[0];
	  int nbSweep  = (*lInfoList["nswp"].get())[0];
	  int nbEnergy = (*lInfoList["nenergy"].get())[0];

	  
	  int fixedIndex = 0;

	  try {

		  fixedIndex = boost::lexical_cast<int>( pAttribute[0] );

	  } catch( boost::bad_lexical_cast const& ) {

		  fixedIndex = 0;
	  }
	  
          bool isMass = false;
	  try {
		  isMass = boost::lexical_cast<bool>( pAttribute[1] );
	  } catch( boost::bad_lexical_cast const& ) {
		  isMass = false;

	  }

          for (int i = 0; i < nbSweep; ++i)

	  {

		  if (isMass) {
			for (int k = 0; k < nbMass; ++k)
			{
                          std::string infoKey = "mass_arr_";
                          infoKey += std::to_string(k * nbEnergy + fixedIndex);
                          _energyList[i].push_back((*lInfoList[infoKey].get())[i]);
			}
                  }
		  else {
		  	for (int k = 0; k < nbEnergy; ++k)
		  	{

			  std::string infoKey = "energy_";

			  infoKey += std::to_string(fixedIndex * nbEnergy + k);

			  _energyList[i].push_back((*lInfoList[infoKey].get())[i]);

		  	}

		  }
	  }
  }

  /**
	 * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
	 */
  void  write(ParamDataIndexInfo &pParamDataIndexInfo) {
    unsigned int index = pParamDataIndexInfo._startIndex;
    for (; index< pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess; index++) {
    	_paramOutput->pushTime(_paramInput.getTime(index));
    	_paramOutput->getDataList().push_back((_energyList[(int)floor(_paramInput.getDataList()[index])]));
    }
  }

private:
	/**
	 * @brief It is the channel of calibration.
	 */
  TParamData &_paramInput;

	/**
	 * @brief It is the channel of the data shifted.
	 */
  ParamDataTab1DDouble *_paramOutput;


	/**
	 * @brief map of calibrationInfo.
	 * @detail for expression #getClbInfo($ETableN;0:ImaEner_0;1:ImaEner_1)
	 * the key of map is 0 respectively  1
	 * the value of map is  the value of attributes  ImaEner[0] respectively and ImaEner[0]
	 */
  std::map<unsigned int , std::vector<double>> _energyList;
};

} /* namespace MavenStatic */
} /* namespace AMDA */
#endif /* GetMavenStaticEnergy_HH_ */