/*
 * ProcessNode.cc
 *
 *  Created on: Oct 31, 2012
 *      Author: f.casimir
 */

#include <sstream>

#include <algorithm>

#include "ProcessNode.hh"


#include <boost/shared_ptr.hpp>

#include <Parameter.hh>
#include <Process.hh>
#include <Parameter.hh>
#include <FileConfigurator.hh>
#include <ServicesServer.hh>

#include "Config.hh"

using namespace AMDA::Parameters;
using namespace boost;

namespace AMDA {
namespace XMLParameterConfigurator {

ProcessNode::ProcessNode() : NodeCfg() {
}

ProcessNode::~ProcessNode() {
}

std::string injectResamplingIntoProcess(const std::string& pProcessName, const std::string& pProcessParams, const std::string& pExpression) {

	std::stringstream lBuffer;
	bool isAParam = false;

	unsigned int length = pExpression.size();
	std::string part;

	for ( unsigned int i = 0; i < length; ++i) {
		switch(pExpression[i]) {

		case '#':
			part = pExpression.substr(i);
			if (part.find("#sum_into_table_range($") == 0) {
				int patternSize = std::string("#sum_into_table_range($").size();
				i += patternSize;
				//special case with sum_into_table_range

				lBuffer << "#" << pProcessName << "(#sum_into_table_range($";

				part = part.substr(patternSize);
				std::size_t pos = part.find(";");
				lBuffer << part.substr(0, pos);
				i += pos;
				part = part.substr(pos);
				pos = part.find(")");
				lBuffer << part.substr(0, pos);
				i += pos;

				lBuffer << ");" << pProcessParams << ")";

			}
			else {
				lBuffer << pExpression[i];
			}
			break;

		case '$':
			isAParam = true;

			lBuffer << "#" << pProcessName << "($";

			break;
		default:
			if( isAParam && ! (isalnum(pExpression[i]) || (pExpression[i]=='_'))) {

				lBuffer << ";" << pProcessParams << ")";

				isAParam=false;
			}
			lBuffer << pExpression[i];
			break;
		}
	}
	if (isAParam) {

		lBuffer << ";" << pProcessParams << ")";

	}

	return std::string(lBuffer.str());
}

void ProcessNode::proceed(xmlNodePtr pNode, const AMDA::Parameters::CfgContext& pContext) {
	LOG4CXX_DEBUG(gLogger, "ProcessNode::proceed");
	Parameter* lParameter = pContext.get<Parameter*>();

	double lTimeResolution = lParameter->getTimeResolution();
	double lGapThreshold = lParameter->getGapThreshold();

	std::string lReferenceParam = lParameter->getReferenceParameter();

	Process *lProcess = ServicesServer::getInstance()->getProcess("standard", *lParameter);

	//process description
	xmlChar *lProcessDesc = xmlGetProp(pNode, (const xmlChar *) "description");
	if (lProcessDesc != NULL)
	{
		lProcess->setDescription(std::string((const char *)lProcessDesc));
		xmlFree(lProcessDesc);
	}

	//user process
	xmlChar *lUserProcess = xmlGetProp(pNode, (const xmlChar *) "userProcess");
	if (lUserProcess != NULL)
	{
		lProcess->setIsUserProcess(strcasecmp ((const char*)lUserProcess, "true") == 0);
		xmlFree(lUserProcess);
	}

	DataWriterSPtr lDataWriter( lProcess);
	std::string* xmlFileName = pContext.get<std::string*>();
	lDataWriter->setSignatureTrigger(*xmlFileName);

	lParameter->setDataWriter(lDataWriter);

	if (pNode->children && pNode->children->content && pNode->children->content[0] != '\0') {

		std::string expression = std::string((char*)pNode->children->content);
		// Remove all aspaces
		expression.erase(std::remove(expression.begin(), expression.end(), ' '), expression.end());

		if (!lReferenceParam.empty()) {
			// Inject Resampling with reference param
			expression = injectResamplingIntoProcess("sampling_under_refparam", lReferenceParam, expression.c_str());
		}
		else if ( lTimeResolution != 0 ) {

			// Inject Resampling

			std::stringstream lProcessParams;

			lProcessParams << lTimeResolution << ";" << lGapThreshold;

			expression = injectResamplingIntoProcess("sampling_classic", lProcessParams.str(), expression.c_str());

		}

		lProcess->setExpression(expression);

	} else {
		if ( lParameter->getParameterList().size() == 1 ) {
			// Inject Resampling

			if (!lReferenceParam.empty()) {
				lProcess = ServicesServer::getInstance()->getProcess("sampling_under_refparam",*lParameter);
				std::stringstream lBuffer;
				lProcess->getAttributList().push_back(lReferenceParam);
				lBuffer.str(""); lBuffer << "$" << (*lParameter->getParameterList().begin())->getId();
				lProcess->setExpression(lBuffer.str());
				lDataWriter.reset( lProcess);
				lParameter->setDataWriter(lDataWriter);
			}
			else if ( lTimeResolution != 0 ) {

				lProcess = ServicesServer::getInstance()->getProcess("sampling_classic",*lParameter);
				std::stringstream lBuffer;
				lBuffer.str(""); lBuffer << lTimeResolution;
				lProcess->getAttributList().push_back(lBuffer.str());
				lBuffer.str(""); lBuffer << lGapThreshold;
				lProcess->getAttributList().push_back(lBuffer.str());
				lBuffer.str(""); lBuffer << "$" << (*lParameter->getParameterList().begin())->getId();
				lProcess->setExpression(lBuffer.str());
				lDataWriter.reset( lProcess);
				lParameter->setDataWriter(lDataWriter);
			}
			else
				//only one parameter + no process => use the same info
				(*lParameter->getParameterList().begin())->setInfoId(lParameter->getInfoId());
		} else {
			ERROR_EXCEPTION( "Too many ParamGet with no process");
		}
	}
}

} /* namespace XMLParameterConfigurator */
} /* namespace AMDA */