#include "../config/pathan_config.h"
/*
 * Copyright (c) 2001, DecisionSoft Limited All rights reserved.
 * Please see LICENSE.TXT for more information.
 */

#include <assert.h>

#include <pathan/internal/navigation/NavStepImpl.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/dom/DOMXPathNamespace.hpp>
#include <xercesc/util/XMLString.hpp>

#include <pathan/XPath2Utils.hpp>
#include <pathan/exceptions/NavigationException.hpp>
#include <pathan/Node.hpp>
#include <pathan/internal/DOMutils/XStr.hpp>

NavStepImpl::NavStepImpl(void) {
  _name = 0; 
  _uri = 0;
  _prefix = 0;
  _type = 0;
  _wildcardName = false;
  _wildcardNamespace = false;
  _wildcardType = false;
  _axisOrientation = FORWARD;
  _usePrefix = false;
  _itemType = 0;
}

NavStepImpl::~NavStepImpl(void) {
  delete _itemType;
}

bool NavStepImpl::filterNode(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node, const XMLCh* const uri, DynamicContext* context) const
{
    //std::cerr << "itemType=" << _itemType << " - Testing a node " << node->getNodeType() << " (" <<
    //          XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(node->getNodeName()) << "," <<
    //          (node->getNodeValue()?XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(node->getNodeValue()):"#NULL") << ")\n";
    if((_itemType!=NULL && _itemType->matches(node,context)) ||
       (_itemType==NULL && checkNodeType(node) && checkNodeName(node) && checkNodeNamespace(node, uri, context)))
    {
      //std::cerr << "we passed the tests" << std::endl;
      return true;
    }//if
    return false;
}

bool NavStepImpl::checkNodeType(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node) const
{

	assert(node != 0);

	if(_wildcardType) {
		return true;
	} else {
		int nodeType = node->getNodeType();

		assert(_type != 0);

		//CDATA nodes are the same as Text, so we need to keep that in mind
		if((_type == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::TEXT_NODE) && (nodeType == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::CDATA_SECTION_NODE)) {
			return true;
		}//if

		//Otherwise, for everything else, we do the usual
		return nodeType == _type;
	}//if
}//checkNodeType

bool NavStepImpl::checkNodeName(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node) const
{
  if(_wildcardName) {
    return true;
  }
  else {
    assert(_name != 0);
    if(_type == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::ELEMENT_NODE || _type == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::ATTRIBUTE_NODE || _type == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::PROCESSING_INSTRUCTION_NODE || XERCES_CPP_NAMESPACE_QUALIFIER DOMXPathNamespace::XPATH_NAMESPACE_NODE) {
      //to make sure we are ok with node created with DOM level 1
      const XMLCh* nodeName = node->getLocalName();
      if(nodeName == NULL) {
        nodeName = node->getNodeName();
      }
      return XPath2Utils::equals(nodeName, _name);
    } else {
      return true;
    }
  }
}



bool NavStepImpl::checkNodeNamespace(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node, const XMLCh* uri, DynamicContext* context) const
{
	const XMLCh* defaultExprNS = context->getDefaultExprNS();

  if(_wildcardNamespace) {
		return true;
  }
  else if(_type != XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::ELEMENT_NODE && _type != XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::ATTRIBUTE_NODE) {
	    return true;
	}
	else {
    if(defaultExprNS == 0 || node->getNodeType() == XERCES_CPP_NAMESPACE_QUALIFIER DOMNode::ATTRIBUTE_NODE) {
		if(uri == 0) {
			return (node->getNamespaceURI() == 0);
		}
		else {
			return (XPath2Utils::equals(node->getNamespaceURI(), uri));
		}
    }
    else {
		if(uri == 0) {
			return (XPath2Utils::equals(node->getNamespaceURI(),defaultExprNS));
		}
		else {
			return (XPath2Utils::equals(node->getNamespaceURI(), uri));
		}
	}
}
}

void NavStepImpl::setAxisOrientation(const AxisOrientation ori)
{
  _axisOrientation = ori;
}


void NavStepImpl::setNodeName(const XMLCh* name)
{
  _name = name;
}

void NavStepImpl::setNodePrefix(const XMLCh* prefix)
{
  _prefix=prefix;
  _usePrefix=true;
}

void NavStepImpl::setNodeUri(const XMLCh* uri)
{
  _uri = uri;
  _usePrefix=false;
}

void NavStepImpl::setNodeType(int type)
{
  _type = type;
}

void NavStepImpl::setNameWildcard(void)
{
  _wildcardName = true;
}

void NavStepImpl::setNamespaceWildcard(void)
{
  _wildcardNamespace = true;
}

void NavStepImpl::setTypeWildcard(void)
{
  _wildcardType = true;
}


int NavStepImpl::getNodeType(void) const
{
  return _type;
}

const XMLCh* NavStepImpl::getNodeUri(void) const
{
  return _uri;
}

const XMLCh* NavStepImpl::getNodePrefix(void) const
{
  return _prefix;
}

const XMLCh* NavStepImpl::getNodeName(void) const
{
  return _name;
}

bool NavStepImpl::getNameWildcard(void) const
{
  return _wildcardName;
}

bool NavStepImpl::getNamespaceWildcard(void) const
{
  return _wildcardNamespace;
}

bool NavStepImpl::getTypeWildcard(void) const
{
  return _wildcardType;
}


bool NavStepImpl::getTypeSet(void) const
{
  return _type != 0;
}

Sequence NavStepImpl::doStep(DynamicContext* context) const
{
  //Account for predicates on non-node base items
  const Item* item = context->getContextItem();

  if(item == 0 || !item->isNode()) {
    DSLthrow(NavigationException,X("NavStepImpl::doStep"), X("An attempt was made to perform an axis step when the Context Item was not a node [err:XP0020]"));
  }

  const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node = ((const Node*)item)->getDOMNode();
  if(node==NULL) {
    DSLthrow(NavigationException,X("NavStepImpl::doStep"), X("An attempt was made to perform an axis step when the Context Item was not a node [err:XP0020]"));
  }

  if(getPrefixSet())
    return makeList(node, context->getUriBoundToPrefix(getNodePrefix()), context);

  return makeList(node, getNodeUri(), context);
}

Sequence NavStepImpl::makeList(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node, const XMLCh* const uri, DynamicContext* context) const {
  XPath2MemoryManager* memMgr=context->getMemoryManager();
  return Sequence(memMgr->createNode(node), memMgr);
}

int NavStepImpl::getAxisOrientation() const {
	return _axisOrientation;
}

bool NavStepImpl::getPrefixSet(void) const {
	return _usePrefix;
}

SequenceType::ItemType* NavStepImpl::getType(void) const {
    return _itemType;
}

void NavStepImpl::setType(SequenceType::ItemType* type) {
    _itemType=type;
}

NavStepImpl::Axis NavStepImpl::getAxis() const {
  return NavStepImpl::UNKNOWN;
}