/*
 * SingleParamProcess.cc
 *
 *  Created on: Feb 6, 2013
 *      Author: f.casimir
 */

#include "Operation.hh"
#include "ParamData.hh"
#include "SingleParamProcess.hh"
#include "ParameterCreatorFromExpression.hh"
#include "ParamMgr.hh"

namespace AMDA {
	namespace Parameters {

		SingleParamProcess::SingleParamProcess(Parameter &parameter) : Process(parameter), _paramInput(NULL), _treatTerminated(false), _expressionParsed(false)
		{
		}

		SingleParamProcess::SingleParamProcess(const SingleParamProcess &pProcess, Parameter &parameter) :
				Process(pProcess,parameter),
				_parameterInput(pProcess._parameterInput),
				_paramInput(NULL), _treatTerminated(false), _expressionParsed(false) {
			  //Establish Connection Without Parse
			  _parameterInput->openConnection(this);
		}

		SingleParamProcess::~SingleParamProcess() {
		}

		void SingleParamProcess::parse() {
				ParameterCreatorFromExpression creator(_parameter.getParameterManager());
				_parameterInput = creator.getOneParameterFromExpression(_parameter,_expression);
		}


		void SingleParamProcess::establishConnection() {
			if (!_expressionParsed)
				parse();
			_expressionParsed = true;
			_parameterInput->openConnection(this);
		}

		unsigned int SingleParamProcess::write() {
		
			int ret = 0;
			unsigned int nbDataBeforeCallProcess = _paramData->getDataNumber();
			ParamDataIndexInfo lParamDataIndexInfo;

			this->_treatTerminated = false;

			lParamDataIndexInfo =_parameterInput->getAsync(this).get();

			while ((!lParamDataIndexInfo._noMoreTimeInt && !lParamDataIndexInfo._timeIntToProcessChanged) || (lParamDataIndexInfo._nbDataToProcess > 0))
			{
				_operation->write(lParamDataIndexInfo);
				ret = _paramData->getDataNumber() - nbDataBeforeCallProcess;
				lParamDataIndexInfo =_parameterInput->getAsync(this).get();
			}

			_operation->write(lParamDataIndexInfo);
                        
                        bool updateDims = (lParamDataIndexInfo._nbDataToProcess > 0) && (lParamDataIndexInfo._startIndex == 0);
                        
			ret = _paramData->getDataNumber() - nbDataBeforeCallProcess;


			// Reset operation to prepare static data for the next TimeInterval.
			if (lParamDataIndexInfo._timeIntToProcessChanged) {
				_paramData->getIndexInfo()._endTimeIntIndexList.push_back(_paramData->getDataNumber());
				_operation->reset();
			}
			// There is no more time interval to process
			else if (lParamDataIndexInfo._noMoreTimeInt) {
				_paramData->getIndexInfo()._endTimeIntIndexList.push_back(_paramData->getDataNumber());
			} else {
				// Nothing to do.
			}

			// Pull up information on which time interval changed.
			_paramData->getIndexInfo()._timeIntToProcessChanged = lParamDataIndexInfo._timeIntToProcessChanged;
			_paramData->getIndexInfo()._noMoreTimeInt = lParamDataIndexInfo._noMoreTimeInt;
                        
                        if (updateDims)
                            _paramData->updateDims();
			
			return ret;
		}

		/*
		 * @brief @ to know the resampling strategy to use. If it's true, the nearest value will be use
		 */
		bool SingleParamProcess::useNearestValue()
		{
			return _parameterInput->getDataWriterTemplate()->useNearestValue();
		}

		/**
		 * @brief update parameter info in relation to the process
		 */
		void SingleParamProcess::updateInfo(Parameter & parameter)
		{
			LOG4CXX_DEBUG(_logger, "SingleParamProcess::updateInfo - " << parameter.getId());

			if (parameter.getInfoId().empty())
				parameter.setInfoId(parameter.getId());

			//just clone param info from input parameter to processed parameter
			AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->cloneParamInfoFromId(_parameterInput->getInfoId(), parameter.getInfoId());

			if (paramInfo == nullptr)
				return;

			//Derived parameter => no comes from a dataset
			paramInfo->setDatasetId("");

			std::string processInfo = "Single param process from '";
			processInfo += _parameterInput->getId();
			processInfo += "'";

			paramInfo->addLinkedParamId(_parameterInput->getId());

			paramInfo->setProcessInfo(processInfo);
		}

		/*
		 * @brief Get min sampling
		 */
		double SingleParamProcess::getMinSampling()
		{
			if (!_expressionParsed)
				parse();
			_expressionParsed = true;
			if (_parameterInput == nullptr)
				return 0;
			if (_parameterInput->getTimeResolution() > 0)
				return _parameterInput->getTimeResolution();
			if (_parameterInput->getDataWriterTemplate() == nullptr)
				return 0;
			return _parameterInput->getDataWriterTemplate()->getMinSampling();
		}
	} /* namespace Parameters */
} /* namespace AMDA */