#include <sys/stat.h>
#include <iostream>

#include "InputParser.h"

#include <xercesc/util/XMLDouble.hpp>



InputParser::InputParser()
{
    try {
        xercesc::XMLPlatformUtils::Initialize();  // Initialize Xerces infrastructure
    }
    catch (xercesc::XMLException& e) {
        char* message = xercesc::XMLString::transcode(e.getMessage());
        std::cout << "XML toolkit initialization error: " << message << std::endl;
        xercesc::XMLString::release(&message);
    }

    // Tags and attributes used in XML file.
    // Can't call transcode till after Xerces Initialize()
    TAG_points     = xercesc::XMLString::transcode("points");
    TAG_point      = xercesc::XMLString::transcode("point");
    TAG_constraints= xercesc::XMLString::transcode("constraints");
    TAG_constraint = xercesc::XMLString::transcode("constraint");
    ATTR_id        = xercesc::XMLString::transcode("id");
    ATTR_x         = xercesc::XMLString::transcode("x");
    ATTR_y         = xercesc::XMLString::transcode("y");
    ATTR_z         = xercesc::XMLString::transcode("z");
    ATTR_point     = xercesc::XMLString::transcode("point");
    ATTR_kind      = xercesc::XMLString::transcode("kind");
    ATTR_distance  = xercesc::XMLString::transcode("distance");

    TAG_GCS_AS = xercesc::XMLString::transcode("GCS_AS");
    TAG_quaternion = xercesc::XMLString::transcode("quaternion");
    TAG_quaternions = xercesc::XMLString::transcode("quaternions");
    TAG_normal = xercesc::XMLString::transcode("normal");
    TAG_normals = xercesc::XMLString::transcode("normals");
    TAG_displacement = xercesc::XMLString::transcode("displacement");
    TAG_displacements = xercesc::XMLString::transcode("displacements");
    TAG_solid = xercesc::XMLString::transcode("solid");
    TAG_solids = xercesc::XMLString::transcode("solids");
    KIND_Parallel_AS = xercesc::XMLString::transcode("Parallel_AS");
    KIND_Distance_AS = xercesc::XMLString::transcode("Distance_AS");
    ATTR_a = xercesc::XMLString::transcode("a");
    ATTR_b= xercesc::XMLString::transcode("b");
    ATTR_c = xercesc::XMLString::transcode("c");
    ATTR_d = xercesc::XMLString::transcode("d");
    ATTR_type = xercesc::XMLString::transcode("type");
    ATTR_quaternion = xercesc::XMLString::transcode("quaternion");
    ATTR_normal = xercesc::XMLString::transcode("normal");
    ATTR_displacement = xercesc::XMLString::transcode("displacement");
    ATTR_solid1 = xercesc::XMLString::transcode("solid1");
    ATTR_solid2 = xercesc::XMLString::transcode("solid2");
    
    
    m_InputFileParser = new xercesc::XercesDOMParser;
}

InputParser::~InputParser()
{
    // Free memory
    delete m_InputFileParser;
}

bool InputParser::readInputFileAS(std::string &fileName,
                                  std::vector<double *> &variables,
                                  std::vector<double *> &parameters,
                                  std::vector<GCS::Point> &points,
                                  std::vector<GCS::Normal> &norms,
                                  std::vector<GCS::Displacement> &disps,
                                  std::vector<GCS::Quaternion> &quats,
				  std::vector<GCS::Solid> &solids,
                                  std::vector<GCS::Constraint *> &constraints)
{
    int pointsOffset = points.size();
    int normsOffset  = norms.size();
    int dispsOffset = disps.size();
    int quatsOffset =  quats.size();
    int solidsOffset = solids.size();

    // Test to see if the file is ok.
    struct stat fileStatus;
    if (stat(fileName.c_str(), &fileStatus) != 0) {
        std::cout << "Error reading the file " << fileName << std::endl;
        return false;
    }

    // Configure DOM parser.
    m_InputFileParser->setValidationScheme(xercesc::XercesDOMParser::Val_Never);
    m_InputFileParser->setDoNamespaces(false);
    m_InputFileParser->setDoSchema(false);
    m_InputFileParser->setLoadExternalDTD(false);

    try {
        m_InputFileParser->parse(fileName.c_str());

        // no need to free this pointer - owned by the parent parser object
        xercesc::DOMDocument* xmlDoc = m_InputFileParser->getDocument();

        // Get the top-level element: Name is "GCS_3D". No attributes for "GCS_3D"
        xercesc::DOMElement* elementRoot = xmlDoc->getDocumentElement();
        if (!elementRoot) {
            std::cout << "empty XML document" << std::endl;
            return false;
        }
        else if (!xercesc::XMLString::equals(elementRoot->getTagName(), TAG_GCS_AS)) {
            std::cout << "wrong root element in the XML file" << std::endl;
            return false;
        }

        // Parse XML file for tags of interest: "ApplicationSettings"
        // Look one level nested within "root". (child of root)
        xercesc::DOMNodeList* children = elementRoot->getChildNodes();
        const XMLSize_t nodeCount = children->getLength();

        // Points
        xercesc::DOMNodeList* pointsNodes = elementRoot->getElementsByTagName(TAG_points);
        const XMLSize_t pointsCount = pointsNodes->getLength();

        for (XMLSize_t i = 0; i < pointsCount; ++i) {
            xercesc::DOMNode* pointsNode = pointsNodes->item(i);
            xercesc::DOMElement* pointsElement = dynamic_cast<xercesc::DOMElement*>(pointsNode);

            xercesc::DOMNodeList* pointNodes = pointsElement->getElementsByTagName(TAG_point);
            const XMLSize_t pointCount = pointNodes->getLength();

            for (XMLSize_t j = 0; j < pointCount; ++j) {
                xercesc::DOMNode* pointNode = pointNodes->item(j);
                xercesc::DOMElement* pointElement = dynamic_cast<xercesc::DOMElement*>(pointNode);

                int id = getIntAttr(pointElement, ATTR_id);
                double x = getDoubleAttr(pointElement, ATTR_x);
                double y = getDoubleAttr(pointElement, ATTR_y);
                double z = getDoubleAttr(pointElement, ATTR_z);

                if (id + pointsOffset > points.size())
                    points.resize(id + pointsOffset);

                GCS::Point p;
                p.x = x;
                p.y = y;
                p.z = z;
                points[id + pointsOffset -1] = p;
            }
        }

        // normals
        xercesc::DOMNodeList* normsNodes = elementRoot->getElementsByTagName(TAG_normals);
        const XMLSize_t normsCount = normsNodes->getLength();

        for (XMLSize_t i = 0; i < normsCount; ++i) {
            xercesc::DOMNode* normsNode = normsNodes->item(i);
            xercesc::DOMElement* normsElement = dynamic_cast<xercesc::DOMElement*>(normsNode);

            xercesc::DOMNodeList* lineNodes = normsElement->getElementsByTagName(TAG_normal);
            const XMLSize_t lineCount = lineNodes->getLength();

            for (XMLSize_t j = 0; j < lineCount; ++j) {
                xercesc::DOMNode* normNode = lineNodes->item(j);
                xercesc::DOMElement* normElement = dynamic_cast<xercesc::DOMElement*>(normNode);

                int id 	 = getIntAttr(normElement, ATTR_id);
                double x = getDoubleAttr(normElement, ATTR_x);
                double y = getDoubleAttr(normElement, ATTR_y);
                double z = getDoubleAttr(normElement, ATTR_z);

                if (id + normsOffset > norms.size())
                    norms.resize(id + normsOffset);

                GCS::Normal p;
                p.x = x;
                p.y = y;
                p.z = z;
                norms[id + normsOffset -1] = p;
            }
        }

         // Displacements
        xercesc::DOMNodeList* dispsNodes = elementRoot->getElementsByTagName(TAG_displacements);
        const XMLSize_t dispsCount = dispsNodes->getLength();

        for (XMLSize_t i = 0; i < dispsCount; ++i) {
            xercesc::DOMNode* dispsNode = dispsNodes->item(i);
            xercesc::DOMElement* dispsElement = dynamic_cast<xercesc::DOMElement*>(dispsNode);

            xercesc::DOMNodeList* lineNodes = dispsElement->getElementsByTagName(TAG_displacement);
            const XMLSize_t lineCount = lineNodes->getLength();

            for (XMLSize_t j = 0; j < lineCount; ++j) {
                xercesc::DOMNode* dispNode = lineNodes->item(j);
                xercesc::DOMElement* dispElement = dynamic_cast<xercesc::DOMElement*>(dispNode);

                int id 	 = getIntAttr(dispElement, ATTR_id);
                double x = getDoubleAttr(dispElement, ATTR_x);
                double y = getDoubleAttr(dispElement, ATTR_y);
                double z = getDoubleAttr(dispElement, ATTR_z);

                if (id + dispsOffset > disps.size())
                    disps.resize(id + dispsOffset);

                // Memory allocation!!
                int varStartIndex = variables.size();
                variables.push_back(new double(x));
                variables.push_back(new double(y));
                variables.push_back(new double(z));

                GCS::Displacement p;
                p.x = variables[varStartIndex+0];
                p.y = variables[varStartIndex+1];
                p.z = variables[varStartIndex+2];
                disps[id + dispsOffset -1] = p;
            }
        }

        // Quaternions
        xercesc::DOMNodeList* quatsNodes = elementRoot->getElementsByTagName(TAG_quaternions);
        const XMLSize_t quatCount = quatsNodes->getLength();

        for (XMLSize_t i = 0; i < quatCount; ++i) {
            xercesc::DOMNode* quatsNode = quatsNodes->item(i);
            xercesc::DOMElement* quatsElement = dynamic_cast<xercesc::DOMElement*>(quatsNode);

            xercesc::DOMNodeList* quatNodes = quatsElement->getElementsByTagName(TAG_quaternion);
            const XMLSize_t quatCount = quatNodes->getLength();

            for (XMLSize_t j = 0; j < quatCount; ++j) {
                xercesc::DOMNode* quatNode = quatNodes->item(j);
                xercesc::DOMElement* quatElement = dynamic_cast<xercesc::DOMElement*>(quatNode);

                int id = getIntAttr(quatElement, ATTR_id);
                double a = getDoubleAttr(quatElement, ATTR_a);
                double b = getDoubleAttr(quatElement, ATTR_b);
                double c = getDoubleAttr(quatElement, ATTR_c);
                double d = getDoubleAttr(quatElement, ATTR_d);

                if (id + quatsOffset > quats.size())
                    quats.resize(id + quatsOffset);

                GCS::Quaternion q;
                // Memory allocation!!
                int varStartIndex = variables.size();
                variables.push_back(new double(a));
                variables.push_back(new double(b));
                variables.push_back(new double(c));
                variables.push_back(new double(d));

                q.a = variables[varStartIndex+0];
                q.b = variables[varStartIndex+1];
                q.c = variables[varStartIndex+2];
                q.d = variables[varStartIndex+3];
                quats[id + quatsOffset -1] = q;
            }
        }
        
        // Solids
        xercesc::DOMNodeList* solidsNodes = elementRoot->getElementsByTagName(TAG_solids);
        const XMLSize_t solidCount = solidsNodes->getLength();

        for (XMLSize_t i = 0; i < solidCount; ++i) {
            xercesc::DOMNode* solidsNode = solidsNodes->item(i);
            xercesc::DOMElement* solidsElement = dynamic_cast<xercesc::DOMElement*>(solidsNode);

            xercesc::DOMNodeList* solidNodes = solidsElement->getElementsByTagName(TAG_solid);
            const XMLSize_t solidCount = solidNodes->getLength();

            for (XMLSize_t j = 0; j < solidCount; ++j) {
                xercesc::DOMNode* solidNode = solidNodes->item(j);
                xercesc::DOMElement* solidElement = dynamic_cast<xercesc::DOMElement*>(solidNode);

                int id 	= getIntAttr(solidElement, ATTR_id);
                int p 	= getIntAttr(solidElement, ATTR_point);
		int n 	= getIntAttr(solidElement, ATTR_normal);
		int d 	= getIntAttr(solidElement, ATTR_displacement);
		int q 	= getIntAttr(solidElement, ATTR_quaternion);

                GCS::Solid s;
                s.p = points[p-1];
		s.n = norms[n-1];
		s.d = disps[d-1];
		s.q = quats[q-1];
		
		solids.push_back(s);
            }
        }
        
        

        // Constraints
        xercesc::DOMNodeList* constraintsNodes = elementRoot->getElementsByTagName(TAG_constraints);
        const XMLSize_t constraintsCount = constraintsNodes->getLength();

        for (XMLSize_t i = 0; i < constraintsCount; ++i) {
            xercesc::DOMNode* constraintsNode = constraintsNodes->item(i);
            xercesc::DOMElement* constraintsElement = dynamic_cast<xercesc::DOMElement*>(constraintsNode);

            xercesc::DOMNodeList* constraintNodes = constraintsElement->getElementsByTagName(TAG_constraint);
            const XMLSize_t constraintCount = constraintNodes->getLength();

            for (XMLSize_t j = 0; j < constraintCount; ++j) {
                xercesc::DOMNode* constraintNode = constraintNodes->item(j);
                xercesc::DOMElement* constraintElement = dynamic_cast<xercesc::DOMElement*>(constraintNode);

                int id = getIntAttr(constraintElement, ATTR_id);

                const XMLCh* xmlch_kind = constraintElement->getAttribute(ATTR_kind);

		//PlaneParallel Assembly
                if (xercesc::XMLString::equals(xmlch_kind, KIND_Parallel_AS)) {
                    int s1 = getIntAttr(constraintElement, ATTR_solid1);
                    int s2 = getIntAttr(constraintElement, ATTR_solid2);
		    int t  = getIntAttr(constraintElement, ATTR_type);

                    int paramStartIndex = parameters.size();
                    parameters.push_back(new double(t));

                    GCS::Constraint *constr
                    = new GCS::ConstraintParralelFaceAS( solids[s1-1], solids[s2-1], 
							 (GCS::ParallelType*) parameters[paramStartIndex] );
                    constraints.push_back(constr);
                }
                //Distance Assembly
                if (xercesc::XMLString::equals(xmlch_kind, KIND_Distance_AS)) {
                    int s1 = getIntAttr(constraintElement, ATTR_solid1);
                    int s2 = getIntAttr(constraintElement, ATTR_solid2);
		    double t  = getDoubleAttr(constraintElement, ATTR_distance);

                    int paramStartIndex = parameters.size();
                    parameters.push_back(new double(t));

                    GCS::Constraint *constr
                    = new GCS::ConstraintFaceDistanceAS( solids[s1-1], solids[s2-1], parameters[paramStartIndex] );
                    constraints.push_back(constr);
                }
            }
        }
        return true;
    }
    catch (xercesc::XMLException& e) {
        char* message = xercesc::XMLString::transcode(e.getMessage());
        std::cout << "Error parsing file: " << message << std::endl;
        xercesc::XMLString::release(&message);
    }
}

int InputParser::getIntAttr(xercesc::DOMElement* element, XMLCh* attr)
{
    const XMLCh* xmlch_val = element->getAttribute(attr);
    return xercesc::XMLString::parseInt(xmlch_val);
}

double InputParser::getDoubleAttr(xercesc::DOMElement* element, XMLCh* attr)
{
    const XMLCh* xmlch_val = element->getAttribute(attr);
    xercesc::XMLDouble xmldouble_val(xmlch_val);
    return xmldouble_val.getValue();
}