/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */


// Class header file.
#include "VariablesStack.hpp"


#include <algorithm>


#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>


#include "ElemVariable.hpp"
#include "StylesheetExecutionContext.hpp"


namespace XALAN_CPP_NAMESPACE {


VariablesStack::VariablesStack(MemoryManager& theManager) :
    m_stack(theManager),
    m_globalStackFrameIndex(~0u),
    m_globalStackFrameMarked(false),
    m_currentStackFrameIndex(0),
    m_guardStack(theManager),
    m_elementFrameStack(theManager)
{
    m_stack.reserve(eDefaultStackSize);
}


VariablesStack::~VariablesStack()
{
}


void
VariablesStack::reset()
{
    while(m_stack.empty() == false)
    {
        pop();
    }

    m_stack.clear();
    m_guardStack.clear();
    m_elementFrameStack.clear();

    m_globalStackFrameMarked = false;
    m_globalStackFrameIndex = ~0u;
}


bool
VariablesStack::elementFrameAlreadyPushed(const ElemTemplateElement*    elem) const
{
    const VariableStackStackType::size_type     nElems = m_stack.size();
    assert(nElems > 0);

    // There is guaranteed to be a context marker at
    // the bottom of the stack, so i should stop at
    // 1.
    for(VariableStackStackType::size_type i = nElems - 1; i > 0; --i)
    {
        const StackEntry&   theEntry = m_stack[i];

        if(theEntry.getType() == StackEntry::eElementFrameMarker)
        {
            if(theEntry.getElement() == elem)
            {
                return true;
            }
        }
    }

    return false;
}


void
VariablesStack::pushContextMarker()
{
    push(StackEntry());
}


void
VariablesStack::popContextMarker()
{
    VariableStackStackType::iterator    i = m_stack.end();

    for(; ;)
    {
        assert(i != m_stack.begin());

        const StackEntry&           theEntry = *--i;
        assert(theEntry == back());

        const StackEntry::eType     type = theEntry.getType();
        assert(type < StackEntry::eNextValue && type >= 0);

        pop();

        if (type == StackEntry::eContextMarker)
        {
            break;
        }
    }

    // This introduced a regression into 1.7, because of all the
    // external fiddling with the stack frame index.  We need to
    // re-write that code so no external meddling is necessary,
    // so we can track the stack frame index properly.  In particular,
    // this is an issue with xsl:apply-templates, because a context
    // marker is pushed before its select attribute is evaluated, even
    // though the select expression really should be evaluated in
    // the previous stack context.
//  m_currentStackFrameIndex = size_type(m_stack.size());
}


void
VariablesStack::push(const StackEntry&  theEntry)
{
    assert(theEntry.getType() < StackEntry::eNextValue && theEntry.getType() >= 0);

    if(m_currentStackFrameIndex == m_stack.size())
    {
        ++m_currentStackFrameIndex;
    }

    m_stack.push_back(theEntry);

    // Increment the global stack frame index as long as we're pushing variables, and
    // it already hasn't been marked.  This is a temporary work-around for problems
    // with evaluating top-level variables as they're pushed, rather than as they're
    // used.
    if (m_globalStackFrameMarked == false && theEntry.getType() == StackEntry::eVariable)
    {
        m_globalStackFrameIndex = m_currentStackFrameIndex;
    }
}


void
VariablesStack::pop()
{
    assert(m_stack.empty() == false);

    if(m_currentStackFrameIndex == m_stack.size())
    {
        --m_currentStackFrameIndex;
    }

    m_stack.pop_back();
}


void
VariablesStack::PushParamFunctor::operator()(const VariablesStack::ParamsVectorType::value_type&    theEntry) const
{
    assert(theEntry.m_qname != 0);

    if (theEntry.m_value.null() == false)
    {
        m_variablesStack.push(VariablesStack::StackEntry(theEntry.m_qname, theEntry.m_value, true));
    }
    else
    {
        assert(theEntry.m_variable != 0);

        m_variablesStack.push(VariablesStack::StackEntry(theEntry.m_qname, theEntry.m_variable, true));
    }
}


VariablesStack::CommitPushParams::CommitPushParams(VariablesStack&  theVariablesStack) :
    m_variablesStack(&theVariablesStack),
    m_stackSize(theVariablesStack.getStackSize())
{
}


VariablesStack::CommitPushParams::~CommitPushParams()
{
    if (m_variablesStack != 0)
    {
        while(m_variablesStack->getStackSize() > m_stackSize)
        {
            m_variablesStack->pop();
        }
    }
}


void
VariablesStack::pushParams(const ParamsVectorType&  theParams)
{
    // This object will push the params and pop them
    // if we don't call it's commit() member function.  So
    // if an exception is thrown while transferring the
    // parameters, the stack stays in a consistent state.
    CommitPushParams    thePusher(*this);

    using std::for_each;

    for_each(theParams.begin(), theParams.end(), PushParamFunctor(*this));

    thePusher.commit();
}


void
VariablesStack::pushVariable(
            const XalanQName&           name,
            const ElemVariable*         var,
            const ElemTemplateElement*  e)
{
    if(elementFrameAlreadyPushed(e) == false)
    {
        pushElementFrame(e);
    }

    push(StackEntry(&name, var));
}


void
VariablesStack::pushVariable(
            const XalanQName&           name,
            const XObjectPtr&           val,
            const ElemTemplateElement*  e)
{
    if(elementFrameAlreadyPushed(e) == false)
    {
        XalanDOMString theBuffer(m_stack.getMemoryManager());

        throw InvalidStackContextException(theBuffer);
    }

    push(StackEntry(&name, val));
}


void
VariablesStack::start()
{
}


void
VariablesStack::resetParams()
{
    const size_type     nElems = getCurrentStackFrameIndex();
    assert(nElems > 0);

    // There is guaranteed to be a context marker at
    // the bottom of the stack, so i should stop at
    // 1.
    for(size_type i = nElems - 1; i > 0; --i)
    {
        StackEntry&     theEntry = m_stack[i];

        if(theEntry.getType() == StackEntry::eContextMarker)
        {
            break;
        }
        else
        {
            theEntry.deactivate();
        }
    }
}


void
VariablesStack::markGlobalStackFrame()
{
    m_globalStackFrameIndex = size_type(m_stack.size());

    m_globalStackFrameMarked = true;

    pushContextMarker();
}


void
VariablesStack::unmarkGlobalStackFrame()
{
    popContextMarker();

    m_globalStackFrameIndex = ~0u;

    m_globalStackFrameMarked = false;
}


const XObjectPtr
VariablesStack::findXObject(
            const XalanQName&               name,
            StylesheetExecutionContext&     executionContext,
            bool                            fIsParam,
            bool                            fSearchGlobalSpace,
            bool&                           fNameFound)
{
    typedef VariableStackStackType::size_type   size_type;

    // findEntry() returns an index into the stack.  We should
    // _never_ take the address of anything in the stack, since
    // the address could change at unexpected times.
    const size_type     theEntryIndex =
        findEntry(name, fIsParam, fSearchGlobalSpace);

    if (theEntryIndex == m_stack.size())
    {
        fNameFound = false;

        return XObjectPtr();
    }
    else
    {
        assert(theEntryIndex < m_stack.size());

        fNameFound = true;

        assert(m_stack[theEntryIndex].getType() == StackEntry::eVariable ||
               m_stack[theEntryIndex].getType() == StackEntry::eParam ||
               m_stack[theEntryIndex].getType() == StackEntry::eActiveParam);

        const XObjectPtr&   theValue = m_stack[theEntryIndex].getValue();

        if (theValue.null() == false)
        {
            return theValue;
        }
        else
        {
            const ElemVariable* const   var = m_stack[theEntryIndex].getVariable();

            XObjectPtr                  theNewValue;

            if (var != 0)
            {
                XalanNode* const    doc = executionContext.getRootDocument();
                assert(doc != 0);

                using std::find;

                // See if the ElemVariable instance is already being evaluated...
                if (find(m_guardStack.begin(), m_guardStack.end(), var) != m_guardStack.end())
                {
                    const StylesheetExecutionContext::GetCachedString   theGuard(executionContext);

                    executionContext.problem(
                        StylesheetExecutionContext::eXSLTProcessor,
                        StylesheetExecutionContext::eError,
                        XalanMessageLoader::getMessage(
                            theGuard.get(),
                            XalanMessages::CircularVariableDefWasDetected),
                        var->getLocator(),
                        doc);
                }

                m_guardStack.push_back(var);

#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
                executionContext.pushContextMarker();
#else
                // We need to set up a stack frame for the variable's execution...
                typedef StylesheetExecutionContext::PushAndPopContextMarker PushAndPopContextMarker;

                const PushAndPopContextMarker   theContextMarkerPushPop(executionContext);
#endif

                theNewValue = var->getValue(executionContext, doc);
                assert(theNewValue.null() == false);

#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
                executionContext.popContextMarker();
#endif

                assert(m_guardStack.empty() == false);

                m_guardStack.pop_back();

                m_stack[theEntryIndex].setValue(theNewValue);
                m_stack[theEntryIndex].activate();
            }

            return theNewValue;
        }
    }
}


VariablesStack::size_type
VariablesStack::findEntry(
            const XalanQName&   qname,
            bool                fIsParam,
            bool                fSearchGlobalSpace)
{
    size_type   theEntryIndex = size_type(m_stack.size());

    const size_type     nElems = getCurrentStackFrameIndex();

    // There is guaranteed to be a context marker at
    // the bottom of the stack, so i should stop at
    // 1.
    for(size_type i = nElems - 1; i > 0; --i)
    {
        StackEntry&                 theEntry = m_stack[i];

        const StackEntry::eType     theType = theEntry.getType();

        if(theType == StackEntry::eVariable ||
           theType == StackEntry::eActiveParam)
        {
            assert(theEntry.getName() != 0);

            if(theEntry.getName()->equals(qname))
            {
                theEntryIndex = i;

                break;
            }
        }
        else if (theType == StackEntry::eParam)
        {
            if (fIsParam == true)
            {
                if(theEntry.getName()->equals(qname))
                {
                    theEntry.activate();

                    theEntryIndex = i;

                    break;
                }
            }
        }
        else if(theType == StackEntry::eContextMarker)
        {
            break;
        }
    }

    if(theEntryIndex == m_stack.size() && fIsParam == false && true == fSearchGlobalSpace && m_globalStackFrameIndex > 1)
    {
        // Look in the global space
        for(size_type i = m_globalStackFrameIndex - 1; i > 0; i--)
        {
            StackEntry&     theEntry = m_stack[i];

            const StackEntry::eType     theType = theEntry.getType();

            if(theType == StackEntry::eVariable)
            {
                assert(theEntry.getName() != 0);

                if(theEntry.getName()->equals(qname))
                {
                    theEntryIndex = i;

                    break;
                }
            }
            else if(theType == StackEntry::eContextMarker)
            {
                break;
            }
        }
    }

    return theEntryIndex;
}


void
VariablesStack::pushElementFrame(const ElemTemplateElement* elem)
{
    push(StackEntry(elem));

#if !defined(NDEBUG)
    m_elementFrameStack.push_back(elem);
#endif
}


class EnsurePop
{
public:

    EnsurePop(VariablesStack&   theVariablesStack) :
        m_variablesStack(theVariablesStack)
    {
    }

    ~EnsurePop()
    {
        m_variablesStack.pop();
    }

private:

    VariablesStack&     m_variablesStack;
};


void
VariablesStack::popElementFrame()
{
    const VariableStackStackType::size_type     nElems = m_stack.size();
    assert(nElems > 0);

    // There is guaranteed to be a context marker at
    // the bottom of the stack, so i should stop at
    // 1.
    for(VariableStackStackType::size_type i = nElems - 1; i > 0; --i)
    {
        const StackEntry&   theEntry = m_stack[i];

        // Guarantee that it will be popped when we're done.
        const EnsurePop     theEnsurePop(*this);

        if(theEntry.getType() == StackEntry::eContextMarker)
        {
            XalanDOMString theBuffer(m_stack.getMemoryManager());

            throw InvalidStackContextException(theBuffer);
        }
        else if (theEntry.getType() == StackEntry::eElementFrameMarker)
        {
#if !defined(NDEBUG)
            const ElemTemplateElement* const    theElement =
                theEntry.getElement();

            if (m_elementFrameStack.empty() == true)
            {
                XalanDOMString theBuffer(m_stack.getMemoryManager());

                throw InvalidStackContextException(theBuffer);
            }

            const ElemTemplateElement* const    theStackBack =
                m_elementFrameStack.back();

            m_elementFrameStack.pop_back();

            if (theElement != theStackBack)
            {
                XalanDOMString theBuffer(m_stack.getMemoryManager());

                throw InvalidStackContextException(theBuffer);
            }
#endif

            break;
        }
    }
}


VariablesStack::StackEntry::StackEntry() :
    m_type(eContextMarker),
    m_qname(0),
    m_value(),
    m_variable(0),
    m_element(0)
{
}


VariablesStack::StackEntry::StackEntry(
            const XalanQName*   name,
            const XObjectPtr&   val,
            bool                isParam) :
    m_type(isParam == true ? eParam : eVariable),
    m_qname(name),
    m_value(val),
    m_variable(0),
    m_element(0)
{
}


VariablesStack::StackEntry::StackEntry(
            const XalanQName*       name,
            const ElemVariable*     var,
            bool                    isParam) :
    m_type(isParam == true ? eParam : eVariable),
    m_qname(name),
    m_value(),
    m_variable(var),
    m_element(0)
{
}


VariablesStack::StackEntry::StackEntry(const ElemTemplateElement*   elem) :
    m_type(eElementFrameMarker),
    m_qname(0),
    m_value(),
    m_variable(0),
    m_element(elem)
{
}


VariablesStack::StackEntry::StackEntry(const StackEntry&    theSource) :
    m_type(theSource.m_type),
    m_qname(theSource.m_qname),
    m_value(theSource.m_value),
    m_variable(theSource.m_variable),
    m_element(theSource.m_element)
{
}


VariablesStack::StackEntry::~StackEntry()
{
}


VariablesStack::StackEntry&
VariablesStack::StackEntry::operator=(const StackEntry&     theRHS)
{
    if (this != &theRHS)
    {
        m_type = theRHS.m_type;

        m_qname = theRHS.m_qname;

        m_value = theRHS.m_value;

        m_variable = theRHS.m_variable;

        m_element = theRHS.m_element;
    }

    return *this;
}


// Equality for StackEntry instances is probably bogus,
// so it might be worthwhile to just get rid of this.
bool
VariablesStack::StackEntry::operator==(const StackEntry&    theRHS) const
{
    bool    fResult = false;

    if (m_type == theRHS.m_type)
    {
        if (m_type == eContextMarker)
        {
            if (&theRHS == this)
            {
                fResult = true;
            }
        }
        else if (m_type == eVariable || m_type == eParam || m_type == eActiveParam)
        {
            // We only need to compare the variable related members...
            if (m_value == theRHS.m_value ||
                m_variable == theRHS.m_variable)
            {
                fResult = true;
            }
        }
        else if (m_type == eElementFrameMarker)
        {
            if (m_element == theRHS.m_element)
            {
                fResult = true;
            }
        }
        else
        {
            assert(0);
        }
    }

    return fResult;
}


void
VariablesStack::StackEntry::activate()
{
    if (m_type == eParam)
    {
        m_type = eActiveParam;
    }
}


void
VariablesStack::StackEntry::deactivate()
{
    if (m_type == eActiveParam)
    {
        m_type = eParam;
    }
}


const XalanDOMChar  VariablesStack::InvalidStackContextException::m_type[] = 
{   
    XalanUnicode::charLetter_I,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_v,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_l,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_d,
    XalanUnicode::charLetter_S,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_a,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_k,
    XalanUnicode::charLetter_C,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_n,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_x,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_E,
    XalanUnicode::charLetter_x,
    XalanUnicode::charLetter_c,
    XalanUnicode::charLetter_e,
    XalanUnicode::charLetter_p,
    XalanUnicode::charLetter_t,
    XalanUnicode::charLetter_i,
    XalanUnicode::charLetter_o,
    XalanUnicode::charLetter_n,
    0
};


VariablesStack::InvalidStackContextException::InvalidStackContextException(XalanDOMString& theResult) :
    XSLTProcessorException(
        theResult.getMemoryManager(),
        XalanMessageLoader::getMessage(
            theResult,
            XalanMessages::InvalidStackContext))
{
}


VariablesStack::InvalidStackContextException::~InvalidStackContextException()
{
}


}