/*
 * Copyright (c) 2001, 2008,
 *     DecisionSoft Limited. All rights reserved.
 * Copyright (c) 2004, 2011,
 *     Oracle and/or its affiliates. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _STATICCONTEXT_HPP
#define _STATICCONTEXT_HPP

#include <xqilla/framework/XQillaExport.hpp>
#include <xqilla/simple-api/XQilla.hpp>
#include <time.h>
#include <xqilla/schema/DocumentCache.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMemory.hpp>

class DynamicContext;
class XPath2MemoryManager;
class FuncFactory;
class DatatypeFactory;
class Collation;
class VariableTypeStore;
class ItemFactory;
class StaticType;
class ModuleResolver;
class ExternalFunctionResolver;
class MessageListener;
class ExternalFunction;
class XQillaConfiguration;
class XQUserFunction;
class XQillaNSResolver;

// Copied from ASTNode.hpp
typedef std::vector<ASTNode*,XQillaAllocator<ASTNode*> > VectorOfASTNodes;
typedef std::vector<XQUserFunction*, XQillaAllocator<XQUserFunction*> > UserFunctions;

XERCES_CPP_NAMESPACE_BEGIN
class DOMDocument;
class DOMXPathNSResolver;
class XMLEntityResolver;
XERCES_CPP_NAMESPACE_END

/// The parse time static context interface
class XQILLA_API StaticContext : public XERCES_CPP_NAMESPACE_QUALIFIER XMemory
{
public:
  typedef enum {
      ORDERING_ORDERED,
      ORDERING_UNORDERED
  } NodeSetOrdering;

  typedef enum {
    CONSTRUCTION_MODE_PRESERVE,
    CONSTRUCTION_MODE_STRIP
  } ConstructionMode;

  typedef enum {
    FLWOR_ORDER_EMPTY_GREATEST,
    FLWOR_ORDER_EMPTY_LEAST
  } FLWOROrderingMode;

  typedef enum {
      NONE,
      CASE_INSENSITIVE,
      CASE_SENSITIVE,
      UPPERCASE,
      LOWERCASE
  } FTCaseOption;

  virtual ~StaticContext() {};

  virtual DynamicContext *createModuleContext(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr =
                                              XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::fgMemoryManager) const = 0;
  virtual DynamicContext *createDynamicContext(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr =
                                               XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::fgMemoryManager) const = 0;

  virtual DynamicContext *createDebugQueryContext(const Item::Ptr &contextItem,
                                                  size_t contextPosition,
                                                  size_t contextSize,
                                                  const VariableStore *variables,
                                                  const XERCES_CPP_NAMESPACE_QUALIFIER DOMXPathNSResolver *nsResolver,
                                                  const XMLCh *defaultElementNS,
                                                  XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr =
                                                  XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::fgMemoryManager) const = 0;

  /** Returns the configuration object for this context */
  virtual XQillaConfiguration *getConfiguration() const = 0;

  /** Returns the lanuage that this context is for. This value cannot be set, since it is used
      to correctly construct the StaticContext */
  virtual XQilla::Language getLanguage() const = 0;
  
  /** Returns the ItemFactory for this context, which is used to create XQilla items and other objects. */
  virtual ItemFactory *getItemFactory() const = 0;
  /** Sets the ItemFactory for this context */
  virtual void setItemFactory(ItemFactory *factory) = 0;

  /** Get the static type of the context item */
  virtual const StaticType &getContextItemType() const = 0;
  /** Set the static type of the context item */
  virtual void setContextItemType(const StaticType &st) = 0;

  /** Get the current XPath 1.0 compatibility mode */
  virtual bool getXPath1CompatibilityMode() const = 0;
  /** Set the current XPath 1.0 compatibility mode */
  virtual void setXPath1CompatibilityMode(bool newMode) = 0;

  /** Get the NS resolver */
  virtual const XERCES_CPP_NAMESPACE_QUALIFIER DOMXPathNSResolver* getNSResolver() const = 0;
  /** returns the URI that is bound in prefix in the current scope or zero
      length string otherwise */
  virtual const XMLCh* getUriBoundToPrefix(const XMLCh* prefix, const LocationInfo *location = 0) const = 0;
  /** returns the prefix that is bound in uri in the current scope or zero
      length string otherwise */
  virtual const XMLCh* getPrefixBoundToUri(const XMLCh* uri) const = 0;
  /** Set the NS resolver */
  virtual void setNSResolver(const XERCES_CPP_NAMESPACE_QUALIFIER DOMXPathNSResolver* resolver) = 0;
  /** Binds a prefix to a namespace URI */
  virtual void setNamespaceBinding(const XMLCh* prefix, const XMLCh* uri) = 0;

  /** get the value of the default namespace for elements and types */
  virtual const XMLCh* getDefaultElementAndTypeNS() const = 0;
  /** set the value of the default namespace for elements and types */
  virtual void setDefaultElementAndTypeNS(const XMLCh* newNS) = 0;

  /** Return the default namespace for functions */
  virtual const XMLCh* getDefaultFuncNS() const = 0;
  /** Set the default namespace for functions */
  virtual void setDefaultFuncNS(const XMLCh* newNS) = 0;

  /** retrieve the repository for the grammars **/
  virtual DocumentCache* getDocumentCache() const = 0;
  /** sets the repository for the grammars **/
  virtual void setDocumentCache(DocumentCache* docCache) = 0;

  /** returns true if the type represented by uri:typename is an instance of uriToCheck:typeNameToCheck 
   *
   * ie: to check 
   * xs:integer instance of xs:decimal, 
   * call
   * isTypeOrDerivedFromType("xs", "integer", "xs", "decimal") 
   * (except of course, call with URIs, not prefixes!)
   */
  virtual bool isTypeOrDerivedFromType(const XMLCh* const uri, const XMLCh* const typeName, const XMLCh* const uriToCheck, const XMLCh* const typeNameToCheck) const = 0;
  /**
   * Sets the XMLEntityResolver that is used by Xerces when it is used
   * to parse documents. This affects the behaviour of XQilla whenever
   * it retrieves a DTD or XML Schema grammar.
   */
  virtual void setXMLEntityResolver(XERCES_CPP_NAMESPACE_QUALIFIER XMLEntityResolver* const handler) = 0;
  /** Returns the entity resolver currently set */
  virtual XERCES_CPP_NAMESPACE_QUALIFIER XMLEntityResolver* getXMLEntityResolver() const = 0;

  /** Register a callback object for resolving module URIs */
  virtual void setModuleResolver(ModuleResolver *resolver) = 0;
  /** Returns the module resolver currently set */
  virtual ModuleResolver *getModuleResolver() const = 0;
  /* Retrieve a list of locations for the given module URI */
  virtual VectorOfStrings* resolveModuleURI(const XMLCh* uri) const = 0;

  /** add the location for the grammar of a specific namespace **/
  virtual void addSchemaLocation(const XMLCh* uri, VectorOfStrings* locations, const LocationInfo *location = 0) = 0;

  /** get the variable type store */
  virtual VariableTypeStore* getVariableTypeStore() = 0;

  /** adds a template definition to the template tables */
  virtual void addTemplate(XQUserFunction *tp) = 0;
  /** look up a template definition by name */
  virtual const XQUserFunction *lookUpNamedTemplate(const XMLCh *uri, const XMLCh *name) const = 0;
  /** Return a vector of all the templates with patterns */
  virtual const UserFunctions &getTemplateRules() const = 0;

  /** adds a custom function to the function table */
  virtual void addCustomFunction(FuncFactory *func) = 0;
  /** removes a custom function to the function table */
  virtual void removeCustomFunction(FuncFactory *func) = 0;
  /** returns a function object with the given uri, localname and number of arguments triple */
  virtual ASTNode *lookUpFunction(const XMLCh *uri, const XMLCh *name, const VectorOfASTNodes &v, const LocationInfo *location = 0) const = 0;

  /** Register a callback object for resolving external function implementations */
  virtual void setExternalFunctionResolver(ExternalFunctionResolver *resolver) = 0;
  /** Returns the external function resolver currently set */
  virtual ExternalFunctionResolver *getExternalFunctionResolver() const = 0;
  /** adds an external function implementation to the function table */
  virtual void addExternalFunction(const ExternalFunction *func) = 0;
  /** returns an external function implementation for the given uri and localname */
  virtual const ExternalFunction *lookUpExternalFunction(const XMLCh *uri, const XMLCh *name, size_t numArgs) const = 0;

  /** Get the implementation for the specified collation */
  virtual Collation* getCollation(const XMLCh* const URI, const LocationInfo *location = 0) const = 0;
  /** Add a collation */
  virtual void addCollation(Collation* collation) = 0;
  
  /** Get the default collation */
  virtual Collation* getDefaultCollation(const LocationInfo *location = 0) const = 0;
  /** Specify which collation is the default one */
  virtual void setDefaultCollation(const XMLCh* const URI) = 0;

  /** Return the base URI */
  virtual const XMLCh* getBaseURI() const = 0;
  /** Set the base URI */
  virtual void setBaseURI(const XMLCh* newURI) = 0;

  /** Return the ordering method for node sets */
  virtual NodeSetOrdering getNodeSetOrdering() const = 0;
  /** Set the ordering method for node sets */
  virtual void setNodeSetOrdering(NodeSetOrdering newOrder) = 0;

  /** Return the construction mode */
  virtual ConstructionMode getConstructionMode() const = 0;
  /** Set the construction mode */
  virtual void setConstructionMode(ConstructionMode newMode) = 0;

  /** Set the policy for boundary space */
  virtual void setPreserveBoundarySpace(bool value) = 0;
  /** Get the policy for boundary  space */
  virtual bool getPreserveBoundarySpace() const = 0;

  /** Return the default ordering mode for FLWOR blocks */
  virtual FLWOROrderingMode getDefaultFLWOROrderingMode() const = 0;
  /** Set the default ordering mode for FLWOR blocks */
  virtual void setDefaultFLWOROrderingMode(FLWOROrderingMode newMode) = 0;

  /** Set the policy for namespace inheritance */
  virtual void setInheritNamespaces(bool value) = 0;
  /** Get the policy for namespace inheritance */
  virtual bool getInheritNamespaces() const = 0;

  /** Set the policy for namespace copy */
  virtual void setPreserveNamespaces(bool value) = 0;
  /** Get the policy for namespace copy */
  virtual bool getPreserveNamespaces() const = 0;

  /** Set the revalidation mode */
  virtual void setRevalidationMode(DocumentCache::ValidationMode mode) = 0;
  /** Get the revalidation mode */
  virtual DocumentCache::ValidationMode getRevalidationMode() const = 0;

  /** Set the listener for warning and trace messages */
  virtual void setMessageListener(MessageListener *listener) = 0;
  /** Gets the listener for warning and trace messages */
  virtual MessageListener *getMessageListener() const = 0;

  /** Set the module */
  virtual void setModule(XQQuery *module) = 0;
  /** Get the module */
  virtual XQQuery *getModule() const = 0;

  /////////////////////////////////////////
  //  XQilla context specific accessors  //
  /////////////////////////////////////////

  /**
   * Gets whether document projection is enabled.
   *
   * Document projection is an optimisation that uses query analysis
   * to remove sub-trees from documents that aren't needed by the
   * query. This results in substantially smaller memory usage and
   * faster query times, but means that any subsequent querying on the
   * results of an initial query can be wrong.
   *
   * If you are hoping to perform further queries on the results of a
   * query, you should turn document projection off to avoid incorrect
   * results.
   */
  virtual bool getProjection() const = 0;
  /**
   * Sets whether document projection is enabled. Document projection
   * can be enabled or disabled at compile time, as well as overridden
   * at runtime. By default document projection is enabled unless query
   * complilation is unable to guarentee its correctness.
   *
   * Document projection is an optimisation that uses query analysis
   * to remove sub-trees from documents that aren't needed by the
   * query. This results in substantially smaller memory usage and
   * faster query times, but means that any subsequent querying on the
   * results of an initial query can be wrong.
   *
   * If you are hoping to perform further queries on the results of a
   * query, you should turn document projection off to avoid incorrect
   * results.
   */
  virtual void setProjection(bool enabled) = 0;

  virtual bool getDoLintWarnings() const = 0;
  virtual void setDoLintWarnings(bool enabled) = 0;

  /** Return a unique name that can be used for a temporary variable */
  virtual const XMLCh *allocateTempVarName(const XMLCh *prefix = 0) = 0;

  /** Get the memory manager */
  virtual XPath2MemoryManager* getMemoryManager() const = 0;
  /** Set the memory manager to the one given */
  virtual void setMemoryManager(XPath2MemoryManager* memMgr) = 0;

  /** Set default full text query case option. */
  virtual void setFTCase(FTCaseOption option) = 0;
  virtual FTCaseOption getFTCase() = 0;
};

#endif
