/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

/* Patternist */
#include "qbasictypesfactory_p.h"
#include "qcommonnamespaces_p.h"
#include "qgenericdynamiccontext_p.h"
#include "qfunctionfactorycollection_p.h"
#include "qgenericnamespaceresolver_p.h"

#include "qgenericstaticcontext_p.h"

QT_BEGIN_NAMESPACE

using namespace QPatternist;

GenericStaticContext::GenericStaticContext(const NamePool::Ptr &np,
                                           QAbstractMessageHandler *const handler,
                                           const QUrl &aBaseURI,
                                           const FunctionFactory::Ptr &factory,
                                           const QXmlQuery::QueryLanguage lang) : m_boundarySpacePolicy(BSPStrip)
                                                                                , m_constructionMode(CMPreserve)
                                                                                , m_functionFactory(factory)
                                                                                , m_defaultFunctionNamespace(CommonNamespaces::XFN)
                                                                                , m_orderingEmptySequence(Greatest)
                                                                                , m_orderingMode(Ordered)
                                                                                , m_defaultCollation(QUrl::fromEncoded(CommonNamespaces::UNICODE_COLLATION))
                                                                                , m_baseURI(aBaseURI)
                                                                                , m_messageHandler(handler)
                                                                                , m_preserveMode(Preserve)
                                                                                , m_inheritMode(Inherit)
                                                                                , m_namespaceResolver(lang == QXmlQuery::XQuery10
                                                                                                      ? GenericNamespaceResolver::defaultXQueryBindings()
                                                                                                      : GenericNamespaceResolver::defaultXSLTBindings())
                                                                                , m_namePool(np)
                                                                                , m_uriResolver(0)
                                                                                , m_queryLanguage(lang)
                                                                                , m_rangeSlot(-1)
                                                                                , m_compatModeEnabled(false)
{
    /* We'll easily have at least this many AST nodes, that we need
     * to track locations for. */
    m_locations.reserve(30);

    Q_ASSERT(np);
    Q_ASSERT(!m_baseURI.isRelative());
}

NamespaceResolver::Ptr GenericStaticContext::namespaceBindings() const
{
    return m_namespaceResolver;
}

FunctionFactory::Ptr GenericStaticContext::functionSignatures() const
{
    return m_functionFactory;
}

DynamicContext::Ptr GenericStaticContext::dynamicContext() const
{
    GenericDynamicContext::Ptr context(new GenericDynamicContext(m_namePool, m_messageHandler, sourceLocations()));
    // TODO we have many bugs here..
    context->setResourceLoader(m_resourceLoader);
    return context;
}

SchemaTypeFactory::Ptr GenericStaticContext::schemaDefinitions() const
{
    return BasicTypesFactory::self(m_namePool);
}

QUrl GenericStaticContext::baseURI() const
{
    Q_ASSERT_X(!m_baseURI.isRelative(), Q_FUNC_INFO,
               "The static base-uri must be absolute. This error is most likely caused by misuing the API.");
    return m_baseURI;
}

void GenericStaticContext::setBaseURI(const QUrl &uri)
{
    Q_ASSERT(!uri.isRelative());
    m_baseURI = uri;
}

bool GenericStaticContext::compatModeEnabled() const
{
    return m_compatModeEnabled;
}

void GenericStaticContext::setCompatModeEnabled(const bool newVal)
{
    m_compatModeEnabled = newVal;
}

QUrl GenericStaticContext::defaultCollation() const
{
    return m_defaultCollation;
}

QAbstractMessageHandler * GenericStaticContext::messageHandler() const
{
    return m_messageHandler;
}

void GenericStaticContext::setDefaultCollation(const QUrl &uri)
{
    m_defaultCollation = uri;
}

void GenericStaticContext::setNamespaceBindings(const NamespaceResolver::Ptr &resolver)
{
    Q_ASSERT(resolver);
    m_namespaceResolver = resolver;
}

StaticContext::BoundarySpacePolicy GenericStaticContext::boundarySpacePolicy() const
{
    return m_boundarySpacePolicy;
}

void GenericStaticContext::setBoundarySpacePolicy(const BoundarySpacePolicy policy)
{
    Q_ASSERT(policy == BSPPreserve || policy == BSPStrip);
    m_boundarySpacePolicy = policy;
}

StaticContext::ConstructionMode GenericStaticContext::constructionMode() const
{
    return m_constructionMode;
}

void GenericStaticContext::setConstructionMode(const ConstructionMode mode)
{
    Q_ASSERT(mode == CMPreserve || mode == CMStrip);
    m_constructionMode = mode;
}

StaticContext::OrderingMode GenericStaticContext::orderingMode() const
{
    return m_orderingMode;
}

void GenericStaticContext::setOrderingMode(const OrderingMode mode)
{
    Q_ASSERT(mode == Ordered || mode == Unordered);
    m_orderingMode = mode;
}

StaticContext::OrderingEmptySequence GenericStaticContext::orderingEmptySequence() const
{
    return m_orderingEmptySequence;
}

void GenericStaticContext::setOrderingEmptySequence(const OrderingEmptySequence ordering)
{
    Q_ASSERT(ordering == Greatest || ordering == Least);
    m_orderingEmptySequence = ordering;
}

QString GenericStaticContext::defaultFunctionNamespace() const
{
    return m_defaultFunctionNamespace;
}

void GenericStaticContext::setDefaultFunctionNamespace(const QString &ns)
{
    m_defaultFunctionNamespace = ns;
}


QString GenericStaticContext::defaultElementNamespace() const
{
    return m_defaultElementNamespace;
}

void GenericStaticContext::setDefaultElementNamespace(const QString &ns)
{
    m_defaultElementNamespace = ns;
}

StaticContext::InheritMode GenericStaticContext::inheritMode() const
{
    return m_inheritMode;
}

void GenericStaticContext::setInheritMode(const InheritMode mode)
{
    Q_ASSERT(mode == Inherit || mode == NoInherit);
    m_inheritMode = mode;
}

StaticContext::PreserveMode GenericStaticContext::preserveMode() const
{
    return m_preserveMode;
}

void GenericStaticContext::setPreserveMode(const PreserveMode mode)
{
    Q_ASSERT(mode == Preserve || mode == NoPreserve);
    m_preserveMode = mode;
}

ItemType::Ptr GenericStaticContext::contextItemType() const
{
    return m_contextItemType;
}

ItemType::Ptr GenericStaticContext::currentItemType() const
{
    return contextItemType();
}

void GenericStaticContext::setContextItemType(const ItemType::Ptr &type)
{
    m_contextItemType = type;
}

StaticContext::Ptr GenericStaticContext::copy() const
{
    GenericStaticContext *const retval = new GenericStaticContext(m_namePool, m_messageHandler, m_baseURI, m_functionFactory, m_queryLanguage);
    const NamespaceResolver::Ptr newSolver(new GenericNamespaceResolver(m_namespaceResolver->bindings()));

    retval->setNamespaceBindings(newSolver);
    retval->setDefaultCollation(m_defaultCollation);
    retval->setBoundarySpacePolicy(m_boundarySpacePolicy);
    retval->setConstructionMode(m_constructionMode);
    retval->setOrderingMode(m_orderingMode);
    retval->setOrderingEmptySequence(m_orderingEmptySequence);
    retval->setDefaultFunctionNamespace(m_defaultFunctionNamespace);
    retval->setInheritMode(m_inheritMode);
    retval->setPreserveMode(m_preserveMode);
    retval->setExternalVariableLoader(m_externalVariableLoader);
    retval->setResourceLoader(m_resourceLoader);
    retval->setContextItemType(m_contextItemType);
    retval->m_locations = m_locations;

    return StaticContext::Ptr(retval);
}

ResourceLoader::Ptr GenericStaticContext::resourceLoader() const
{
    return m_resourceLoader;
}

void GenericStaticContext::setResourceLoader(const ResourceLoader::Ptr &loader)
{
    m_resourceLoader = loader;
}

ExternalVariableLoader::Ptr GenericStaticContext::externalVariableLoader() const
{
    return m_externalVariableLoader;
}

void GenericStaticContext::setExternalVariableLoader(const ExternalVariableLoader::Ptr &loader)
{
    m_externalVariableLoader = loader;
}

NamePool::Ptr GenericStaticContext::namePool() const
{
    return m_namePool;
}

void GenericStaticContext::addLocation(const SourceLocationReflection *const reflection,
                                       const QSourceLocation &location)
{
    Q_ASSERT(!location.isNull());
    Q_ASSERT_X(reflection, Q_FUNC_INFO,
               "The reflection cannot be zero.");
    m_locations.insert(reflection, location);
}

StaticContext::LocationHash GenericStaticContext::sourceLocations() const
{
    return m_locations;
}

QSourceLocation GenericStaticContext::locationFor(const SourceLocationReflection *const reflection) const
{
    return m_locations.value(reflection->actualReflection());
}

QAbstractUriResolver *GenericStaticContext::uriResolver() const
{
    return m_uriResolver;
}

VariableSlotID GenericStaticContext::currentRangeSlot() const
{
    return m_rangeSlot;
}

VariableSlotID GenericStaticContext::allocateRangeSlot()
{
    ++m_rangeSlot;
    return m_rangeSlot;
}

QT_END_NAMESPACE
