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

//note: check up on this - what sets it, cause it dont any more (used to be in NavStepImpl)?
//static bool myUseWholeText = false;

#include <pathan/dataItem/DataItemStep.hpp>
#include <pathan/internal/navigation/NavStepImpl.hpp>
#include <pathan/Item.hpp>
#include <pathan/ATDecimalOrDerived.hpp>
#include <pathan/internal/factory/DatatypeFactory.hpp>
#include <pathan/dataItem/StaticResolutionContext.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>

DataItemStep::DataItemStep(NavStepImpl* step, XPath2MemoryManager* memMgr)
	: DataItemImpl(memMgr), _step(step) {
  setType(DataItem::STEP);
}

DataItemStep::~DataItemStep()
{
	//no-op
}


DataItem* DataItemStep::staticResolution(StaticContext *context, StaticResolutionContext *src)
{
  src->contextItemUsed(true);
  return resolvePredicates(context, src);
}

Sequence DataItemStep::collapseTreeInternal(DynamicContext* context, int flags) const 
{
	return _step->doStep(context);
}

Sequence DataItemStep::checkPredicate(const Sequence &s, const DataItem *predicate, DynamicContext *context) const
{
  if(s.isEmpty()) return s;

  // quick check: if the predicate is just a literal number, return the Nth item in the sequence
  const Numeric *numeric = getConstantNumericPredicate(predicate, context);
  if(numeric != 0) {
    const ATDecimalOrDerived* index = (const ATDecimalOrDerived*)numeric->castAs(XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                                                                                 XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgDT_INTEGER,
                                                                                 context);
    const Numeric* one = DatatypeFactory::POD2AT::createInteger(context->getMemoryManager(), 1, context);
    const Numeric* length = DatatypeFactory::POD2AT::createInteger(context->getMemoryManager(), (long)s.getLength(), context);
    if(index->lessThan(one, context) || index->greaterThan(length, context)) {
      return Sequence(context->getMemoryManager());
    }
    else {
      if(_step->getAxisOrientation() == REVERSE) {
        index = (const ATDecimalOrDerived*)length->subtract(index, context);
      }
      else {
        index = (const ATDecimalOrDerived*)index->subtract(one, context);
      }
      return Sequence(s.item(index), context->getMemoryManager());
    }
  }

  unsigned int oldContextSize = context->getContextSize();
  unsigned int oldContextPosition = context->getContextPosition();
  const Item* oldCurrentItem = context->getContextItem();

  Sequence output(s.getLength(), context->getMemoryManager());
  context->setContextSize(s.getLength());
  int c;
  if(_step->getAxisOrientation() == REVERSE) {
    c = s.getLength();
  }
  else {
    c = 1;
  }
  for(Sequence::const_iterator i = s.begin(); i != s.end(); ++i) {
    context->setContextPosition(c);
    context->setContextItem(*i);
    if(DataItemImpl::checkPredicate(predicate, context)) {
      output.addItem(*i);
    }
    if(_step->getAxisOrientation() == REVERSE) {
      --c;
    }
    else {
      ++c;
    }
  }

  context->setContextSize(oldContextSize);
  context->setContextPosition(oldContextPosition);
  context->setContextItem(oldCurrentItem);

  return output;
}

const NavStepImpl *DataItemStep::getNavStep() const {
  return _step;
}