/**
 * XMLParameterConfigurator.cc
 *
 *  Created on: 17 oct. 2012
 *      Author: AKKA IS
 */

#include <iostream>
#include <sstream>
#include <string>

#include <boost/algorithm/string.hpp>

    using namespace std;
    using namespace boost;

#include "log4cxx/logger.h"

// XML  include
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xmlstring.h>
#include <libxml/xmlschemas.h>

#include "NodeCfg.hh"
#include "Constant.hh"

#include "ParamNode.hh"
#include "XMLParameterConfigurator.hh"
#include "Config.hh"

using namespace log4cxx;
using namespace AMDA::XMLConfigurator;

// Global variable

namespace AMDA
{
  namespace XMLParameterConfigurator
  {
    log4cxx::LoggerPtr gLogger = log4cxx::Logger::getLogger("AMDA-Kernel.XMLParameterConfigurator");

    XMLParameterConfigurator::XMLParameterConfigurator(const char* pXSDFile) : XMLConfigurator(pXSDFile, true)
    {
      LOG4CXX_DEBUG(gLogger, "XMLParameterConfigurator Constructor")
		getXmlConfiguratorMap()["param"] = RootNodeCfgSPtr(new ParamNode);
    }

    XMLParameterConfigurator::~XMLParameterConfigurator()
    {
    }

bool XMLParameterConfigurator::proceed(const char* filename,
		const AMDA::Parameters::CfgContext& pCtx, bool optionalFile) {
	xmlDocPtr lDoc = NULL;
	xmlNodePtr lRoot = NULL;
	std::string configurationFileName = this->getParamPath() + "/" + filename
			+ ".xml";
	LOG4CXX_DEBUG(gLogger, "Filename to parse: " << configurationFileName)
	try {
		if (access(configurationFileName.c_str(), F_OK) != 0) {
			if (optionalFile) {
				LOG4CXX_WARN(gLogger, "Cannot find file: " << configurationFileName)
				return false;
			}
			ERROR_EXCEPTION( ERROR_FILE_NOT_EXIST << configurationFileName);
		}

		if (!(lDoc = xmlParseFile(configurationFileName.c_str()))) {
			ERROR_EXCEPTION( ERROR_BAD_XML_FORMAT);
		}

		//  const char* lParamerterXSD = "DataBaseParameters/xsd/parameter.xsd";
		//  if ( ! is_valid( lDoc, lParamerterXSD)) {
		//      ERROR_EXCEPTION( ERROR_DOC_NOT_VALID << " XSD file: " << lParamerterXSD);
		//    }

		if (!(lRoot = xmlDocGetRootElement(lDoc))) {
			ERROR_EXCEPTION( ERROR_EMPTY_DOCUMENT);
		}
		AMDA::Parameters::CfgContext lContext(pCtx);
		lContext.push<std::string *>(&configurationFileName);

		// XML_XML_ID case
		xmlNs* lNsXML = NULL;
		xmlAttrPtr cur = lRoot->properties;
		while (cur && !lNsXML) {
			if ((xmlStrEqual(cur->name, (const xmlChar *) "id") == 1) && cur->ns
					&& (xmlStrEqual(cur->ns->prefix, (const xmlChar *) "xml")
							== 1)) {
				lNsXML = cur->ns;
				cur->ns = NULL;
			} else {
				cur = cur->next;
			}
		}
		if (!lNsXML) {
			ERROR_EXCEPTION(ERROR_MANDATORY_ATTRIBUTE_MISSING << lRoot->name << "@" << XML_XML_ID)
		}

		if (!NodeCfg::getIsValid(lRoot, _XSDFile)) {
			cur->ns = lNsXML;
			ERROR_EXCEPTION(ERROR_DOC_NOT_VALID << " XSD file: " << _XSDFile);
		}
		cur->ns = lNsXML;

		RootNodeCfgMap::iterator it = getXmlConfiguratorMap().find(
				std::string((const char*) lRoot->name));
		if (it != getXmlConfiguratorMap().end()) {
			it->second->proceed(lRoot, lContext);
		} else {
			ERROR_EXCEPTION( ERROR_ROOT_NODE_NOT_SUPPORTED << lRoot->name);
		}
	} catch (...) {
		if (lDoc) {	xmlFreeDoc(lDoc); }
		throw;
	}
	if (lDoc) {	xmlFreeDoc(lDoc); }
	return true;
}

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