/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is TransforMiiX XSLT Processor.
 *
 * The Initial Developer of the Original Code is
 * Axel Hecht.
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *  Axel Hecht <axel@pike.org>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "txXSLTPatterns.h"
#include "txNodeSetContext.h"
#include "txForwardContext.h"
#include "XSLTFunctions.h"
#include "ProcessorState.h"
#ifndef TX_EXE
#include "nsReadableUtils.h"
#include "nsIContent.h"
#include "nsINodeInfo.h"
#include "XMLUtils.h"
#endif

/*
 * txPattern
 *
 * Base class of all patterns
 * Implements only a default getSimplePatterns
 */
nsresult txPattern::getSimplePatterns(txList& aList)
{
    aList.add(this);
    return NS_OK;
}

txPattern::~txPattern()
{
}


/*
 * txUnionPattern
 *
 * This pattern is returned by the parser for "foo | bar" constructs.
 * |xsl:template|s should use the simple patterns
 */

/*
 * Destructor, deletes all LocationPathPatterns
 */
txUnionPattern::~txUnionPattern()
{
    txListIterator iter(&mLocPathPatterns);
    while (iter.hasNext()) {
        delete (txPattern*)iter.next();
    }
}

nsresult txUnionPattern::addPattern(txPattern* aPattern)
{
    if (!aPattern)
        return NS_ERROR_NULL_POINTER;
    mLocPathPatterns.add(aPattern);
    return NS_OK;
}

/*
 * Returns the default priority of this Pattern.
 * UnionPatterns don't like this.
 * This should be called on the simple patterns.
 */
double txUnionPattern::getDefaultPriority()
{
    NS_ASSERTION(0, "Don't call getDefaultPriority on txUnionPattern");
    return Double::NaN;
}

/*
 * Determines whether this Pattern matches the given node within
 * the given context
 * This should be called on the simple patterns for xsl:template,
 * but is fine for xsl:key and xsl:number
 */
MBool txUnionPattern::matches(Node* aNode, txIMatchContext* aContext)
{
    txListIterator iter(&mLocPathPatterns);
    while (iter.hasNext()) {
        txPattern* p = (txPattern*)iter.next();
        if (p->matches(aNode, aContext)) {
            return MB_TRUE;
        }
    }
    return MB_FALSE;
}

nsresult txUnionPattern::getSimplePatterns(txList& aList)
{
    txListIterator iter(&mLocPathPatterns);
    while (iter.hasNext()) {
        aList.add(iter.next());
        iter.remove();
    }
    return NS_OK;
}

/*
 * The String representation will be appended to any data in the
 * destination String, to allow cascading calls to other
 * toString() methods for mLocPathPatterns.
 */
void txUnionPattern::toString(String& aDest)
{
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txUnionPattern{"));
#endif
    txListIterator iter(&mLocPathPatterns);
    if (iter.hasNext())
        ((txPattern*)iter.next())->toString(aDest);
    while (iter.hasNext()) {
        aDest.Append(NS_LITERAL_STRING(" | "));
        ((txPattern*)iter.next())->toString(aDest);
    }
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
} // toString


/*
 * LocationPathPattern
 *
 * a list of step patterns, can start with id or key
 * (dealt with by the parser)
 */

/*
 * Destructor, deletes all PathPatterns
 */
txLocPathPattern::~txLocPathPattern()
{
    txListIterator iter(&mSteps);
    while (iter.hasNext()) {
         delete (Step*)iter.next();
    }
}

nsresult txLocPathPattern::addStep(txPattern* aPattern, MBool isChild)
{
    if (!aPattern)
        return NS_ERROR_NULL_POINTER;
    Step* step = new Step(aPattern, isChild);
    if (!step)
        return NS_ERROR_OUT_OF_MEMORY;
    mSteps.add(step);
    return NS_OK;
}

MBool txLocPathPattern::matches(Node* aNode, txIMatchContext* aContext)
{
    NS_ASSERTION(aNode && mSteps.getLength(), "Internal error");

    /*
     * The idea is to split up a path into blocks separated by descendant
     * operators. For example "foo/bar//baz/bop//ying/yang" is split up into
     * three blocks. The "ying/yang" block is handled by the first while-loop
     * and the "foo/bar" and "baz/bop" blocks are handled by the second
     * while-loop.
     * A block is considered matched when we find a list of ancestors that
     * match the block. If there are more than one list of ancestors that
     * match a block we only need to find the one furthermost down in the
     * tree.
     */

    txListIterator iter(&mSteps);
    iter.resetToEnd();

    Step* step;
    step = (Step*)iter.previous();
    if (!step->pattern->matches(aNode, aContext))
        return MB_FALSE;
    Node* node = aNode->getXPathParent();

    while (step->isChild) {
        step = (Step*)iter.previous();
        if (!step)
            return MB_TRUE; // all steps matched
        if (!node || !step->pattern->matches(node, aContext))
            return MB_FALSE; // no more ancestors or no match

        node = node->getXPathParent();
    }

    // We have at least one // path separator
    Node *blockStart = node;
    txListIterator blockIter(iter);

    while ((step = (Step*)iter.previous())) {
        if (!node)
            return MB_FALSE; // There are more steps in the current block 
                             // than ancestors of the tested node

        if (!step->pattern->matches(node, aContext)) {
            // Didn't match. We restart at beginning of block using a new
            // start node
            iter = blockIter;
            blockStart = blockStart->getXPathParent();
            node = blockStart;
        }
        else {
            node = node->getXPathParent();
            if (!step->isChild) {
                // We've matched an entire block. Set new start iter and start node
                blockIter = iter;
                blockStart = node;
            }
        }
    }

    return MB_TRUE;
} // txLocPathPattern::matches

double txLocPathPattern::getDefaultPriority()
{
    if (mSteps.getLength() > 1) {
        return 0.5;
    }

    return ((Step*)mSteps.get(0))->pattern->getDefaultPriority();
}

void txLocPathPattern::toString(String& aDest)
{
    txListIterator iter(&mSteps);
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txLocPathPattern{"));
#endif
    Step* step;
    step = (Step*)iter.next();
    if (step) {
        step->pattern->toString(aDest);
    }
    while ((step = (Step*)iter.next())) {
        if (step->isChild)
            aDest.Append(PRUnichar('/'));
        else
            aDest.Append(NS_LITERAL_STRING("//"));
        step->pattern->toString(aDest);
    }
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
} // txLocPathPattern::toString

/*
 * txRootPattern
 *
 * a txPattern matching the document node, or '/'
 */

txRootPattern::~txRootPattern()
{
}

MBool txRootPattern::matches(Node* aNode, txIMatchContext* aContext)
{
    return aNode && (aNode->getNodeType() == Node::DOCUMENT_NODE);
}

double txRootPattern::getDefaultPriority()
{
    return 0.5;
}

void txRootPattern::toString(String& aDest)
{
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txRootPattern{"));
#endif
    if (mSerialize)
        aDest.Append(PRUnichar('/'));
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
}

/*
 * txIdPattern
 *
 * txIdPattern matches if the given node has a ID attribute with one
 * of the space delimited values.
 * This looks like the id() function, but may only have LITERALs as
 * argument.
 */
txIdPattern::txIdPattern(const String& aString)
{
#ifdef TX_EXE
    mIds = aString;
#else
    const nsString& ids = aString.getConstNSString();
    nsAString::const_iterator pos, begin, end;
    ids.BeginReading(begin);
    ids.EndReading(end);
    pos = begin;
    while (pos != end) {
        while (pos != end && XMLUtils::isWhitespace(*pos))
            ++pos;
        begin = pos;
        if (!mIds.IsEmpty())
            mIds += PRUnichar(' ');
        while (pos != end && !XMLUtils::isWhitespace(*pos))
            ++pos;
        mIds += Substring(begin, pos);
    }
#endif
}

txIdPattern::~txIdPattern()
{
}

MBool txIdPattern::matches(Node* aNode, txIMatchContext* aContext)
{
#ifdef TX_EXE
    return MB_FALSE; // not implemented
#else
    if (aNode->getNodeType() != Node::ELEMENT_NODE) {
        return MB_FALSE;
    }

    // Get a ID attribute, if there is

    nsCOMPtr<nsIContent> content = do_QueryInterface(aNode->getNSObj());
    NS_ASSERTION(content, "a Element without nsIContent");
    if (!content) {
        return MB_FALSE;
    }
    nsCOMPtr<nsINodeInfo> ni;
    content->GetNodeInfo(*getter_AddRefs(ni));
    if (!ni) {
        return MB_FALSE;
    }
    nsCOMPtr<nsIAtom> idAttr;
    ni->GetIDAttributeAtom(getter_AddRefs(idAttr));
    if (!idAttr) {
        return MB_FALSE; // no ID for this element defined, can't match
    }
    nsAutoString value;
    nsresult rv = content->GetAttr(kNameSpaceID_None, idAttr, value);
    if (rv != NS_CONTENT_ATTR_HAS_VALUE) {
        return MB_FALSE; // no ID attribute given
    }
    nsAString::const_iterator pos, begin, end;
    mIds.BeginReading(begin);
    mIds.EndReading(end);
    pos = begin;
    const PRUnichar space = PRUnichar(' ');
    PRBool found = FindCharInReadable(space, pos, end);

    while (found) {
        if (value.Equals(Substring(begin, pos))) {
            return MB_TRUE;
        }
        ++pos; // skip ' '
        begin = pos;
        found = FindCharInReadable(PRUnichar(' '), pos, end);
    }
    if (value.Equals(Substring(begin, pos))) {
        return MB_TRUE;
    }
    return MB_FALSE;
#endif // TX_EXE
}

double txIdPattern::getDefaultPriority()
{
    return 0.5;
}

void txIdPattern::toString(String& aDest)
{
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txIdPattern{"));
#endif
    aDest.Append(NS_LITERAL_STRING("id('"));
#ifdef TX_EXE
    aDest.Append(mIds);
#else
    aDest.getNSString().Append(mIds);
#endif
    aDest.Append(NS_LITERAL_STRING("')"));
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
}

/*
 * txKeyPattern
 *
 * txKeyPattern matches if the given node is in the evalation of 
 * the key() function
 * This resembles the key() function, but may only have LITERALs as
 * argument.
 */

txKeyPattern::~txKeyPattern()
{
}

MBool txKeyPattern::matches(Node* aNode, txIMatchContext* aContext)
{
    Document* contextDoc;
    if (aNode->getNodeType() == Node::DOCUMENT_NODE)
        contextDoc = (Document*)aNode;
    else
        contextDoc = aNode->getOwnerDocument();
    txXSLKey* key = mProcessorState->getKey(mName);
    const NodeSet* nodes = key->getNodes(mValue, contextDoc);
    if (!nodes || nodes->isEmpty())
        return MB_FALSE;
    MBool isTrue = nodes->contains(aNode);
    return isTrue;
}

double txKeyPattern::getDefaultPriority()
{
    return 0.5;
}

void txKeyPattern::toString(String& aDest)
{
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txKeyPattern{"));
#endif
    aDest.Append(NS_LITERAL_STRING("key('"));
    String tmp;
    if (mPrefix) {
        TX_GET_ATOM_STRING(mPrefix, tmp);
        aDest.Append(tmp);
        aDest.Append(PRUnichar(':'));
    }
    TX_GET_ATOM_STRING(mName.mLocalName, tmp);
    aDest.Append(tmp);
    aDest.Append(NS_LITERAL_STRING(", "));
    aDest.Append(mValue);
    aDest.Append(NS_LITERAL_STRING("')"));
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
}

/*
 * txStepPattern
 *
 * a txPattern to hold the NodeTest and the Predicates of a StepPattern
 */

txStepPattern::~txStepPattern()
{
    delete mNodeTest;
}

MBool txStepPattern::matches(Node* aNode, txIMatchContext* aContext)
{
    NS_ASSERTION(mNodeTest && aNode, "Internal error");
    if (!aNode)
        return MB_FALSE;

    if (!mNodeTest->matches(aNode, aContext))
        return MB_FALSE;

    if (!mIsAttr && !aNode->getParentNode())
        return MB_FALSE;
    if (isEmpty()) {
        return MB_TRUE;
    }

    /*
     * Evaluate Predicates
     *
     * Copy all siblings/attributes matching mNodeTest to nodes
     * Up to the last Predicate do
     *  Foreach node in nodes
     *   evaluate Predicate with node as context node
     *   if the result is a number, check the context position,
     *    otherwise convert to bool
     *   if result is true, copy node to newNodes
     *  if aNode is not member of newNodes, return MB_FALSE
     *  nodes = newNodes
     *
     * For the last Predicate, evaluate Predicate with aNode as
     *  context node, if the result is a number, check the position,
     *  otherwise return the result converted to boolean
     */

    // Create the context node set for evaluating the predicates
    NodeSet nodes;
    Node* parent = aNode->getXPathParent();
    if (mIsAttr) {
        NamedNodeMap* atts = parent->getAttributes();
        if (atts) {
            PRUint32 i;
            for (i = 0; i < atts->getLength(); i++) {
                Node* attr = atts->item(i);
                if (mNodeTest->matches(attr, aContext))
                    nodes.append(attr);
            }
        }
    }
    else {
        Node* tmpNode = parent->getFirstChild();
        while (tmpNode) {
            if (mNodeTest->matches(tmpNode, aContext))
                nodes.append(tmpNode);
            tmpNode = tmpNode->getNextSibling();
        }
    }

    txListIterator iter(&predicates);
    Expr* predicate = (Expr*)iter.next();
    NodeSet newNodes;

    while (iter.hasNext()) {
        newNodes.clear();
        MBool contextIsInPredicate = MB_FALSE;
        txNodeSetContext predContext(&nodes, aContext);
        while (predContext.hasNext()) {
            predContext.next();
            ExprResult* exprResult = predicate->evaluate(&predContext);
            if (!exprResult)
                break;
            switch(exprResult->getResultType()) {
                case ExprResult::NUMBER :
                    // handle default, [position() == numberValue()]
                    if ((double)predContext.position() ==
                        exprResult->numberValue()) {
                        Node* tmp = predContext.getContextNode();
                        if (tmp == aNode)
                            contextIsInPredicate = MB_TRUE;
                        newNodes.append(tmp);
                    }
                    break;
                default:
                    if (exprResult->booleanValue()) {
                        Node* tmp = predContext.getContextNode();
                        if (tmp == aNode)
                            contextIsInPredicate = MB_TRUE;
                        newNodes.append(tmp);
                    }
                    break;
            }
            delete exprResult;
        }
        // Move new NodeSet to the current one
        nodes.clear();
        nodes.append(&newNodes);
        if (!contextIsInPredicate) {
            return MB_FALSE;
        }
        predicate = (Expr*)iter.next();
    }
    txForwardContext evalContext(aContext, aNode, &nodes);
    ExprResult* exprResult = predicate->evaluate(&evalContext);
    if (!exprResult)
        return MB_FALSE;
    if (exprResult->getResultType() == ExprResult::NUMBER)
        // handle default, [position() == numberValue()]
        return ((double)evalContext.position() == exprResult->numberValue());

    return exprResult->booleanValue();
} // matches

double txStepPattern::getDefaultPriority()
{
    if (isEmpty())
        return mNodeTest->getDefaultPriority();
    return 0.5;
}

void txStepPattern::toString(String& aDest)
{
#ifdef DEBUG
    aDest.Append(NS_LITERAL_STRING("txStepPattern{"));
#endif
    if (mIsAttr)
        aDest.Append(PRUnichar('@'));
    if (mNodeTest)
        mNodeTest->toString(aDest);

    PredicateList::toString(aDest);
#ifdef DEBUG
    aDest.Append(PRUnichar('}'));
#endif
}