/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * 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.

 */

package com.sun.org.apache.xerces.internal.xpointer;

import java.util.HashMap;

import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;

import com.sun.org.apache.xerces.internal.util.SymbolTable;

import com.sun.org.apache.xerces.internal.util.XMLChar;

import com.sun.org.apache.xerces.internal.xni.Augmentations;

import com.sun.org.apache.xerces.internal.xni.QName;

import com.sun.org.apache.xerces.internal.xni.XMLAttributes;

import com.sun.org.apache.xerces.internal.xni.XNIException;

import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;

/**

 * <p>

 * Implements the XPointerPart interface for element() scheme specific processing.

 * </p>

 *

 * @xerces.internal

 *

 */

final class ElementSchemePointer implements XPointerPart {

    // Fields

    // The Scheme Name i.e element

    private String fSchemeName;

    // The scheme Data

    private String fSchemeData;

    // The scheme Data & child sequence

    private String fShortHandPointerName;

    // Should we attempt to resolve the ChildSequence from the

    // current element position. If a ShortHand Pointer is present

    // attempt to resolve relative to the short hand pointer.

    private boolean fIsResolveElement = false;

    // Has the element been found

    private boolean fIsElementFound = false;

    // Was only an empty element found

    private boolean fWasOnlyEmptyElementFound = false;

    // If a shorthand pointer is present and resolved

    boolean fIsShortHand = false;

    // The depth at which the element was found

    int fFoundDepth = 0;

    // The XPointer element child sequence

    private int fChildSequence[];

    // The current child position

    private int fCurrentChildPosition = 1;

    // The current child depth

    private int fCurrentChildDepth = 0;

    // The current element's child sequence

    private int fCurrentChildSequence[];;

    // Stores if the Fragment was resolved by the pointer

    private boolean fIsFragmentResolved = false;

    // Stores if the Fragment was resolved by the pointer

    private ShortHandPointer fShortHandPointer;

    // The XPointer Error reporter

    protected XMLErrorReporter fErrorReporter;

    // The XPointer Error Handler

    protected XMLErrorHandler fErrorHandler;

    //

    private SymbolTable fSymbolTable;

    // ************************************************************************

    // Constructors

    // ************************************************************************

    public ElementSchemePointer() {

    }

    public ElementSchemePointer(SymbolTable symbolTable) {

        fSymbolTable = symbolTable;

    }

    public ElementSchemePointer(SymbolTable symbolTable,

            XMLErrorReporter errorReporter) {

        fSymbolTable = symbolTable;

        fErrorReporter = errorReporter;

    }

    // ************************************************************************

    // XPointerPart implementation

    // ************************************************************************

    /**

     * Parses the XPointer expression and tokenizes it into Strings

     * delimited by whitespace.

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#parseXPointer(java.lang.String)

     */

    public void parseXPointer(String xpointer) throws XNIException {

        //

        init();

        // tokens

        final Tokens tokens = new Tokens(fSymbolTable);

        // scanner

        Scanner scanner = new Scanner(fSymbolTable) {

            protected void addToken(Tokens tokens, int token)

                    throws XNIException {

                if (token == Tokens.XPTRTOKEN_ELEM_CHILD

                        || token == Tokens.XPTRTOKEN_ELEM_NCNAME) {

                    super.addToken(tokens, token);

                    return;

                }

                reportError("InvalidElementSchemeToken", new Object[] { tokens

                        .getTokenString(token) });

            }

        };

        // scan the element() XPointer expression

        int length = xpointer.length();

        boolean success = scanner.scanExpr(fSymbolTable, tokens, xpointer, 0,

                length);

        if (!success) {

            reportError("InvalidElementSchemeXPointer",

                    new Object[] { xpointer });

        }

        // Initialize a temp arrays to the size of token count which should

        // be atleast twice the size of child sequence, to hold the ChildSequence.

        int tmpChildSequence[] = new int[tokens.getTokenCount() / 2 + 1];

        // the element depth

        int i = 0;

        // Traverse the scanned tokens

        while (tokens.hasMore()) {

            int token = tokens.nextToken();

            switch (token) {

            case Tokens.XPTRTOKEN_ELEM_NCNAME: {

                // Note:  Only a single ShortHand pointer can be present

                // The shortHand name

                token = tokens.nextToken();

                fShortHandPointerName = tokens.getTokenString(token);

                // Create a new ShortHandPointer

                fShortHandPointer = new ShortHandPointer(fSymbolTable);

                fShortHandPointer.setSchemeName(fShortHandPointerName);

                break;

            }

            case Tokens.XPTRTOKEN_ELEM_CHILD: {

                tmpChildSequence[i] = tokens.nextToken();

                i++;

                break;

            }

            default:

                reportError("InvalidElementSchemeXPointer",

                        new Object[] { xpointer });

            }

        }

        // Initialize the arrays to the number of elements in the ChildSequence.

        fChildSequence = new int[i];

        fCurrentChildSequence = new int[i];

        System.arraycopy(tmpChildSequence, 0, fChildSequence, 0, i);

    }

    /**

     * Returns the scheme name i.e element

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#getSchemeName()

     */

    public String getSchemeName() {

        return fSchemeName;

    }

    /**

     * Returns the scheme data

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#getSchemeData()

     */

    public String getSchemeData() {

        return fSchemeData;

    }

    /**

     * Sets the scheme name

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#setSchemeName(java.lang.String)

     */

    public void setSchemeName(String schemeName) {

        fSchemeName = schemeName;

    }

    /**

     * Sets the scheme data

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#setSchemeData(java.lang.String)

     */

    public void setSchemeData(String schemeData) {

        fSchemeData = schemeData;

    }

    /**

     * Responsible for resolving the element() scheme XPointer.  If a ShortHand

     * Pointer is present and it is successfully resolved and if a child

     * sequence is present, the child sequence is resolved relative to it.

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#resolveXPointer(com.sun.org.apache.xerces.internal.xni.QName, com.sun.org.apache.xerces.internal.xni.XMLAttributes, com.sun.org.apache.xerces.internal.xni.Augmentations, int event)

     */

    public boolean resolveXPointer(QName element, XMLAttributes attributes,

            Augmentations augs, int event) throws XNIException {

        boolean isShortHandPointerResolved = false;

        // if a ChildSequence exisits, resolve child elements

        // if an element name exists

        if (fShortHandPointerName != null) {

            // resolve ShortHand Pointer

            isShortHandPointerResolved = fShortHandPointer.resolveXPointer(

                    element, attributes, augs, event);

            if (isShortHandPointerResolved) {

                fIsResolveElement = true;

                fIsShortHand = true;

            } else {

                fIsResolveElement = false;

            }

        } else {

            fIsResolveElement = true;

        }

        // Added here to skip the ShortHand pointer corresponding to

        // an element if one exisits and start searching from its child

        if (fChildSequence.length > 0) {

            fIsFragmentResolved = matchChildSequence(element, event);

        } else if (isShortHandPointerResolved && fChildSequence.length <= 0) {

            // if only a resolved shorthand pointer exists

            fIsFragmentResolved = isShortHandPointerResolved;

        } else {

            fIsFragmentResolved = false;

        }

        return fIsFragmentResolved;

    }

    /**

     * Matches the current element position in the document tree with the

     * element position specified in the element XPointer scheme.

     *

     * @param event

     * @return boolean - true if the current element position in the document

     * tree matches theelement position specified in the element XPointer

     * scheme.

     */

    protected boolean matchChildSequence(QName element, int event)

            throws XNIException {

        // need to resize fCurrentChildSequence

        if (fCurrentChildDepth >= fCurrentChildSequence.length) {

            int tmpCurrentChildSequence[] = new int[fCurrentChildSequence.length];

            System.arraycopy(fCurrentChildSequence, 0, tmpCurrentChildSequence,

                    0, fCurrentChildSequence.length);

            // Increase the size by a factor of 2 (?)

            fCurrentChildSequence = new int[fCurrentChildDepth * 2];

            System.arraycopy(tmpCurrentChildSequence, 0, fCurrentChildSequence,

                    0, tmpCurrentChildSequence.length);

        }

        //

        if (fIsResolveElement) {

            // start

            fWasOnlyEmptyElementFound = false;

            if (event == XPointerPart.EVENT_ELEMENT_START) {

                fCurrentChildSequence[fCurrentChildDepth] = fCurrentChildPosition;

                fCurrentChildDepth++;

                // reset the current child position

                fCurrentChildPosition = 1;

                //if (!fSchemeNameFound) {

                if ((fCurrentChildDepth <= fFoundDepth) || (fFoundDepth == 0)) {

                    if (checkMatch()) {

                        fIsElementFound = true;

                        fFoundDepth = fCurrentChildDepth;

                    } else {

                        fIsElementFound = false;

                        fFoundDepth = 0;

                    }

                }

            } else if (event == XPointerPart.EVENT_ELEMENT_END) {

                if (fCurrentChildDepth == fFoundDepth) {

                    fIsElementFound = true;

                } else if (((fCurrentChildDepth < fFoundDepth) && (fFoundDepth != 0))

                        || ((fCurrentChildDepth > fFoundDepth) // or empty element found

                        && (fFoundDepth == 0))) {

                    fIsElementFound = false;

                }

                // reset array position of last child

                fCurrentChildSequence[fCurrentChildDepth] = 0;

                fCurrentChildDepth--;

                fCurrentChildPosition = fCurrentChildSequence[fCurrentChildDepth] + 1;

            } else if (event == XPointerPart.EVENT_ELEMENT_EMPTY) {

                fCurrentChildSequence[fCurrentChildDepth] = fCurrentChildPosition;

                fCurrentChildPosition++;

                // Donot check for empty elements if the empty element is

                // a child of a found parent element

                if (checkMatch()) {

                    if (!fIsElementFound) {

                        fWasOnlyEmptyElementFound = true;

                    } else {

                        fWasOnlyEmptyElementFound = false;

                    }

                    fIsElementFound = true;

                } else {

                    fIsElementFound = false;

                    fWasOnlyEmptyElementFound = false;

                }

            }

        }

        return fIsElementFound;

    }

    /**

     * Matches the current position of the element being visited by checking

     * its position and previous elements against the element XPointer expression.

     * If a match is found it return true else false.

     *

     * @return boolean

     */

    protected boolean checkMatch() {

        // If the number of elements in the ChildSequence is greater than the

        // current child depth, there is not point in checking further

        if (!fIsShortHand) {

            // If a shorthand pointer is not present traverse the children

            // and compare

            if (fChildSequence.length <= fCurrentChildDepth + 1) {

                for (int i = 0; i < fChildSequence.length; i++) {

                    if (fChildSequence[i] != fCurrentChildSequence[i]) {

                        return false;

                    }

                }

            } else {

                return false;

            }

        } else {

            // If a shorthand pointer is present traverse the children

            // ignoring the first element of the CurrenChildSequence which

            // contains the ShortHand pointer element and compare

            if (fChildSequence.length <= fCurrentChildDepth + 1) {

                for (int i = 0; i < fChildSequence.length; i++) {

                    // ensure fCurrentChildSequence is large enough

                    if (fCurrentChildSequence.length < i + 2) {

                        return false;

                    }

                    // ignore the first element of fCurrentChildSequence

                    if (fChildSequence[i] != fCurrentChildSequence[i + 1]) {

                        return false;

                    }

                }

            } else {

                return false;

            }

        }

        return true;

    }

    /**

     * Returns true if the node matches or is a child of a matching element()

     * scheme XPointer.

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#isFragmentResolved()

     */

    public boolean isFragmentResolved() throws XNIException {

        // Return true if the Fragment was resolved and the current Node depth

        // is greater than or equal to the depth at which the element was found

        return fIsFragmentResolved ;

    }

    /**

     * Returns true if the XPointer expression resolves to a non-element child

     * of the current resource fragment.

     *

     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#isChildFragmentResolved()

     *

     */

    public boolean isChildFragmentResolved() {

        // if only a shorthand pointer was present

        if (fIsShortHand && fShortHandPointer != null && fChildSequence.length <= 0) {

                return fShortHandPointer.isChildFragmentResolved();

        } else {

                return fWasOnlyEmptyElementFound ? !fWasOnlyEmptyElementFound

                                : (fIsFragmentResolved && (fCurrentChildDepth >= fFoundDepth));

        }

    }

    /**

         * Reports an XPointer error

         */

    protected void reportError(String key, Object[] arguments)

            throws XNIException {

        /*fErrorReporter.reportError(XPointerMessageFormatter.XPOINTER_DOMAIN,

         key, arguments, XMLErrorReporter.SEVERITY_ERROR);

         */

        throw new XNIException((fErrorReporter

                        .getMessageFormatter(XPointerMessageFormatter.XPOINTER_DOMAIN))

                                .formatMessage(fErrorReporter.getLocale(), key, arguments));

    }

    /**

     * Initializes error handling objects

     */

    protected void initErrorReporter() {

        if (fErrorReporter == null) {

            fErrorReporter = new XMLErrorReporter();

        }

        if (fErrorHandler == null) {

            fErrorHandler = new XPointerErrorHandler();

        }

        fErrorReporter.putMessageFormatter(

                XPointerMessageFormatter.XPOINTER_DOMAIN,

                new XPointerMessageFormatter());

    }

    /**

     * Initializes the element scheme processor

     */

    protected void init() {

        fSchemeName = null;

        fSchemeData = null;

        fShortHandPointerName = null;

        fIsResolveElement = false;

        fIsElementFound = false;

        fWasOnlyEmptyElementFound = false;

        fFoundDepth = 0;

        fCurrentChildPosition = 1;

        fCurrentChildDepth = 0;

        fIsFragmentResolved = false;

        fShortHandPointer = null;

        initErrorReporter();

    }

    // ************************************************************************

    // element() Scheme expression scanner

    // ************************************************************************

    /**

     * List of XPointer Framework tokens.

     *

     * @xerces.internal

     *

     * @author Neil Delima, IBM

     *

     */

    private final class Tokens {

        /**

         * XPointer element() scheme

         * [1]    ElementSchemeData    ::=    (NCName ChildSequence?) | ChildSequence

         * [2]    ChildSequence    ::=    ('/' [1-9] [0-9]*)+

         */

        private static final int XPTRTOKEN_ELEM_NCNAME = 0;

        private static final int XPTRTOKEN_ELEM_CHILD = 1;

        // Token names

        private final String[] fgTokenNames = { "XPTRTOKEN_ELEM_NCNAME",

                "XPTRTOKEN_ELEM_CHILD" };

        // Token count

        private static final int INITIAL_TOKEN_COUNT = 1 << 8;

        private int[] fTokens = new int[INITIAL_TOKEN_COUNT];

        private int fTokenCount = 0;

        // Current token position

        private int fCurrentTokenIndex;

        private SymbolTable fSymbolTable;