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

#include <pathan/functions/FunctionString.hpp>
#include <assert.h>
#include <pathan/XPath2Utils.hpp>
#include <pathan/DynamicContext.hpp>
#include <pathan/ATStringOrDerived.hpp>
#include <pathan/Node.hpp>
#include <pathan/internal/factory/DatatypeFactory.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <pathan/dataItem/StaticResolutionContext.hpp>
#include <pathan/dataItem/DataItemSequence.hpp>

const XMLCh FunctionString::name[] = {
XERCES_CPP_NAMESPACE_QUALIFIER chLatin_s, XERCES_CPP_NAMESPACE_QUALIFIER chLatin_t, XERCES_CPP_NAMESPACE_QUALIFIER chLatin_r, XERCES_CPP_NAMESPACE_QUALIFIER chLatin_i, XERCES_CPP_NAMESPACE_QUALIFIER chLatin_n, XERCES_CPP_NAMESPACE_QUALIFIER chLatin_g, XERCES_CPP_NAMESPACE_QUALIFIER chNull };

/**
 * fn:string() as xs:string
 * fn:string($arg as item()?) as xs:string
**/

FunctionString::FunctionString(const VectorOfDataItems &args, XPath2MemoryManager* memMgr)
  : DataItemFunction(name,0, 1, "item()?", args, memMgr)
{
}

DataItem* FunctionString::staticResolution(StaticContext *context, StaticResolutionContext *src) {
  if(_args.empty()) {
    src->contextItemUsed(true);
  }
  return resolveDataItems(_args, context, src, !_args.empty());
}

Sequence FunctionString::collapseTreeInternal(DynamicContext* context, int flags) const
{
	XPath2MemoryManager* memMgr = context->getMemoryManager();

  const Item* item;
	if(getNumArgs() == 0)
		item=context->getContextItem();
	else
	{
		Sequence arg=getParamNumber(1,context);
		if(arg.isEmpty())
			return Sequence(DatatypeFactory::STR2AT::createString(memMgr, XERCES_CPP_NAMESPACE_QUALIFIER XMLUni::fgZeroLenString, context), memMgr);
		item=arg.first();
	}
	if (item->isNode()) {
    const Node* xNode = (const Node*)item;
    const XMLCh *nodeStr = xNode->dmStringValue(context);
    const ATStringOrDerived* result = DatatypeFactory::STR2AT::createString(memMgr, nodeStr, context);
    return Sequence(result, memMgr);
  } else if (item->isAtomicValue()) {
    const AnyAtomicType* atom = (const AnyAtomicType*)item;
    if (atom->isOfType(XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                       XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgDT_ANYURI, context)) {
      return Sequence(DatatypeFactory::STR2AT::createString(memMgr, atom->asString(context), context), memMgr);
    } else {
      return Sequence((const ATStringOrDerived*)atom->castAs(XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgURI_SCHEMAFORSCHEMA,
                                                              XERCES_CPP_NAMESPACE_QUALIFIER SchemaSymbols::fgDT_STRING, context), memMgr);
    }
	}

  assert(false);    
	return Sequence(memMgr);
}