/*
 * FunctionsArgsListParser.cc
 *
 *  Created on: Dec 03, 2020
 *      Author: AKKA
 */

#include "NodeCfg.hh"
#include "AMDA_exception.hh"
#include "FunctionsArgsListParser.hh"
#include "ParserLogger.hh"

#include <boost/lexical_cast.hpp>

using namespace AMDA::XMLConfigurator;

namespace AMDA {
namespace parser {

///////////////////////////////////////////////////////////////////////////////
/*
 * @brief value node
 */
class ArgListValueNode : public NodeCfg
{
public:
	void proceed(xmlNodePtr pNode,const AMDA::Parameters::CfgContext& pContext) {
		ArgListInfo *pArgListInfo =  pContext.get<ArgListInfo *>();

		//Get key
		xmlChar* value = xmlGetProp(pNode, (const xmlChar *) "key");
		std::string argKey;
		if (value != NULL)
		{
			argKey = (char *)value;
			xmlFree(value);
		}
			
		//Get value
		value = xmlGetProp(pNode, (const xmlChar *) "value");
		std::string argValue;
		if (value != NULL)
		{
			argValue = (char *)value;
			xmlFree(value);
		}

		if (!argKey.empty()) {
			pArgListInfo->addValue(argKey, argValue);
		}
	}
};

///////////////////////////////////////////////////////////////////////////////
/*
 * @brief values node
 */
class ArgListValuesNode : public NodeGrpCfg {
public:

	ArgListValuesNode () : NodeGrpCfg() {
		getChildList()["value"] = NodeCfgSPtr(new ArgListValueNode);
	}

	void proceed(xmlNodePtr pNode, const AMDA::Parameters::CfgContext& pContext) {
		LOG4CXX_INFO(gLogger, "ArgListValuesNode::proceed");

                // Proceed nodes
                NodeGrpCfg::proceed(pNode, pContext);
	}
};

///////////////////////////////////////////////////////////////////////////////
/*
 * @brief arglist node
 */
class ArgListNode : public NodeGrpCfg
{
public:

	ArgListNode () : NodeGrpCfg() {
		getChildList()["values"] = RootNodeCfgSPtr(new ArgListValuesNode);
	}

	void proceed(xmlNodePtr pNode,const AMDA::Parameters::CfgContext& pContext) {
		//Get id
		xmlChar* value = xmlGetProp(pNode, (const xmlChar *) "id");
		std::string id;
		if (value != NULL)
		{
			id = (char *)value;
			xmlFree(value);
		}

		if (!id.empty()) {
			AMDA::Parameters::CfgContext ctx;
			ArgListInfo argListInfo;
			ctx.push<ArgListInfo *>(&argListInfo);

			argListInfo.setID(id);

			// Proceed nodes
			NodeGrpCfg::proceed(pNode, ctx);

			//Add functions argument list in map
			ArgListInfoMap *pArgListInfoMap =  pContext.get<ArgListInfoMap *>();
			(*pArgListInfoMap)[id] = argListInfo;
		}
	}
};

///////////////////////////////////////////////////////////////////////////////
/*
 * @brief argslist node
 */
class ArgsListNode : public NodeGrpCfg {
public:

	ArgsListNode () : NodeGrpCfg() {
		getChildList()["arglist"] = NodeCfgSPtr(new ArgListNode);
	}

	void proceed(xmlNodePtr pNode, const AMDA::Parameters::CfgContext& pContext) {
		LOG4CXX_INFO(gLogger, "ArgsListNode::proceed");

		// Proceed nodes
		NodeGrpCfg::proceed(pNode, pContext);
	}
};

///////////////////////////////////////////////////////////////////////////////
/*
 * @brief argslist node parser
 */
FunctionsArgsListParser::FunctionsArgsListParser (const char* pXSDFile) : XMLConfigurator(pXSDFile,true)
{
	// argslist root node
	getXmlConfiguratorMap()["argslist"] = RootNodeCfgSPtr(new ArgsListNode ());
}

ArgListInfoMap FunctionsArgsListParser::parse (const std::string& functionsArgsListFile) {
	LOG4CXX_INFO(gLogger, "FunctionsArgsListParser::parse parsing " << functionsArgsListFile);

	AMDA::Parameters::CfgContext ctx;
	ArgListInfoMap argListInfoMap;
	ctx.push<ArgListInfoMap *>(&argListInfoMap);

	// Check schema validity and parse xml file
	try {
		if (!XMLConfigurator::proceed(functionsArgsListFile.c_str(), ctx, true)) {
			return argListInfoMap;
		}
	}
	catch (...) {
		LOG4CXX_INFO(gLogger, "FunctionsArgsListParser::parse error while parsing file " << functionsArgsListFile);
		return argListInfoMap;
	}
	return argListInfoMap;
}

} /* namespace parser */
} /* namespace AMDA */