/*

 * Copyright (c) 1999, 2000, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.swing.text.html;

import java.io.*;

/**

 * A CSS parser. This works by way of a delegate that implements the

 * CSSParserCallback interface. The delegate is notified of the following

 * events:

 * <ul>

 *   <li>Import statement: <code>handleImport</code>

 *   <li>Selectors <code>handleSelector</code>. This is invoked for each

 *       string. For example if the Reader contained p, bar , a {}, the delegate

 *       would be notified 4 times, for 'p,' 'bar' ',' and 'a'.

 *   <li>When a rule starts, <code>startRule</code>

 *   <li>Properties in the rule via the <code>handleProperty</code>. This

 *       is invoked one per property/value key, eg font size: foo;, would

 *       cause the delegate to be notified once with a value of 'font size'.

 *   <li>Values in the rule via the <code>handleValue</code>, this is notified

 *       for the total value.

 *   <li>When a rule ends, <code>endRule</code>

 * </ul>

 * This will parse much more than CSS 1, and loosely implements the

 * recommendation for <i>Forward-compatible parsing</i> in section

 * 7.1 of the CSS spec found at:

 * <a href=http://www.w3.org/TR/REC-CSS1>http://www.w3.org/TR/REC-CSS1</a>.

 * If an error results in parsing, a RuntimeException will be thrown.

 * <p>

 * This will preserve case. If the callback wishes to treat certain poritions

 * case insensitively (such as selectors), it should use toLowerCase, or

 * something similar.

 *

 * @author Scott Violet

 */

class CSSParser {

    // Parsing something like the following:

    // (@rule | ruleset | block)*

    //

    // @rule       (block | identifier)*; (block with {} ends @rule)

    // block       matching [] () {} (that is, [()] is a block, [(){}{[]}]

    //                                is a block, ()[] is two blocks)

    // identifier  "*" | '*' | anything but a [](){} and whitespace

    //

    // ruleset     selector decblock

    // selector    (identifier | (block, except block '{}') )*

    // declblock   declaration* block*

    // declaration (identifier* stopping when identifier ends with :)

    //             (identifier* stopping when identifier ends with ;)

    //

    // comments /* */ can appear any where, and are stripped.

    // identifier - letters, digits, dashes and escaped characters

    // block starts with { ends with matching }, () [] and {} always occur

    //   in matching pairs, '' and "" also occur in pairs, except " may be

    // Indicates the type of token being parsed.

    private static final int   IDENTIFIER = 1;

    private static final int   BRACKET_OPEN = 2;

    private static final int   BRACKET_CLOSE = 3;

    private static final int   BRACE_OPEN = 4;

    private static final int   BRACE_CLOSE = 5;

    private static final int   PAREN_OPEN = 6;

    private static final int   PAREN_CLOSE = 7;

    private static final int   END = -1;

    private static final char[] charMapping = { 0, 0, '[', ']', '{', '}', '(',

                                               ')', 0};

    /** Set to true if one character has been read ahead. */

    private boolean        didPushChar;

    /** The read ahead character. */

    private int            pushedChar;

    /** Temporary place to hold identifiers. */

    private StringBuffer   unitBuffer;

    /** Used to indicate blocks. */

    private int[]          unitStack;

    /** Number of valid blocks. */

    private int            stackCount;

    /** Holds the incoming CSS rules. */

    private Reader         reader;

    /** Set to true when the first non @ rule is encountered. */

    private boolean        encounteredRuleSet;

    /** Notified of state. */

    private CSSParserCallback callback;

    /** nextToken() inserts the string here. */

    private char[]         tokenBuffer;

    /** Current number of chars in tokenBufferLength. */

    private int            tokenBufferLength;

    /** Set to true if any whitespace is read. */

    private boolean        readWS;

    // The delegate interface.

    static interface CSSParserCallback {

        /** Called when an @import is encountered. */

        void handleImport(String importString);

        // There is currently no way to distinguish between '"foo,"' and

        // 'foo,'. But this generally isn't valid CSS. If it becomes

        // a problem, handleSelector will have to be told if the string is

        // quoted.

        void handleSelector(String selector);

        void startRule();

        // Property names are mapped to lower case before being passed to

        // the delegate.

        void handleProperty(String property);

        void handleValue(String value);

        void endRule();

    }

    CSSParser() {

        unitStack = new int[2];

        tokenBuffer = new char[80];

        unitBuffer = new StringBuffer();

    }

    void parse(Reader reader, CSSParserCallback callback,

               boolean inRule) throws IOException {

        this.callback = callback;

        stackCount = tokenBufferLength = 0;

        this.reader = reader;

        encounteredRuleSet = false;

        try {

            if (inRule) {

                parseDeclarationBlock();

            }

            else {

                while (getNextStatement());

            }

        } finally {

            callback = null;

            reader = null;

        }

    }

    /**

     * Gets the next statement, returning false if the end is reached. A

     * statement is either an @rule, or a ruleset.

     */

    private boolean getNextStatement() throws IOException {

        unitBuffer.setLength(0);

        int token = nextToken((char)0);

        switch (token) {

        case IDENTIFIER:

            if (tokenBufferLength > 0) {

                if (tokenBuffer[0] == '@') {

                    parseAtRule();

                }

                else {

                    encounteredRuleSet = true;

                    parseRuleSet();

                }

            }

            return true;

        case BRACKET_OPEN:

        case BRACE_OPEN:

        case PAREN_OPEN:

            parseTillClosed(token);

            return true;

        case BRACKET_CLOSE:

        case BRACE_CLOSE:

        case PAREN_CLOSE:

            // Shouldn't happen...

            throw new RuntimeException("Unexpected top level block close");

        case END:

            return false;

        }

        return true;

    }

    /**

     * Parses an @ rule, stopping at a matching brace pair, or ;.

     */

    private void parseAtRule() throws IOException {

        // PENDING: make this more effecient.

        boolean        done = false;

        boolean isImport = (tokenBufferLength == 7 &&

                            tokenBuffer[0] == '@' && tokenBuffer[1] == 'i' &&

                            tokenBuffer[2] == 'm' && tokenBuffer[3] == 'p' &&

                            tokenBuffer[4] == 'o' && tokenBuffer[5] == 'r' &&

                            tokenBuffer[6] == 't');

        unitBuffer.setLength(0);

        while (!done) {

            int       nextToken = nextToken(';');

            switch (nextToken) {

            case IDENTIFIER:

                if (tokenBufferLength > 0 &&

                    tokenBuffer[tokenBufferLength - 1] == ';') {

                    --tokenBufferLength;

                    done = true;

                }

                if (tokenBufferLength > 0) {

                    if (unitBuffer.length() > 0 && readWS) {

                        unitBuffer.append(' ');

                    }

                    unitBuffer.append(tokenBuffer, 0, tokenBufferLength);

                }

                break;

            case BRACE_OPEN:

                if (unitBuffer.length() > 0 && readWS) {

                    unitBuffer.append(' ');

                }

                unitBuffer.append(charMapping[nextToken]);

                parseTillClosed(nextToken);

                done = true;

                // Skip a tailing ';', not really to spec.

                {

                    int nextChar = readWS();

                    if (nextChar != -1 && nextChar != ';') {

                        pushChar(nextChar);

                    }

                }

                break;

            case BRACKET_OPEN: case PAREN_OPEN:

                unitBuffer.append(charMapping[nextToken]);

                parseTillClosed(nextToken);

                break;

            case BRACKET_CLOSE: case BRACE_CLOSE: case PAREN_CLOSE:

                throw new RuntimeException("Unexpected close in @ rule");

            case END:

                done = true;

                break;

            }

        }

        if (isImport && !encounteredRuleSet) {

            callback.handleImport(unitBuffer.toString());

        }

    }

    /**

     * Parses the next rule set, which is a selector followed by a

     * declaration block.

     */

    private void parseRuleSet() throws IOException {

        if (parseSelectors()) {

            callback.startRule();

            parseDeclarationBlock();

            callback.endRule();

        }

    }

    /**

     * Parses a set of selectors, returning false if the end of the stream

     * is reached.

     */

    private boolean parseSelectors() throws IOException {

        // Parse the selectors

        int       nextToken;

        if (tokenBufferLength > 0) {

            callback.handleSelector(new String(tokenBuffer, 0,

                                               tokenBufferLength));

        }

        unitBuffer.setLength(0);

        for (;;) {

            while ((nextToken = nextToken((char)0)) == IDENTIFIER) {

                if (tokenBufferLength > 0) {

                    callback.handleSelector(new String(tokenBuffer, 0,

                                                       tokenBufferLength));

                }

            }

            switch (nextToken) {

            case BRACE_OPEN:

                return true;

            case BRACKET_OPEN: case PAREN_OPEN:

                parseTillClosed(nextToken);

                // Not too sure about this, how we handle this isn't very

                // well spec'd.

                unitBuffer.setLength(0);

                break;

            case BRACKET_CLOSE: case BRACE_CLOSE: case PAREN_CLOSE:

                throw new RuntimeException("Unexpected block close in selector");

            case END:

                // Prematurely hit end.

                return false;

            }

        }

    }

    /**

     * Parses a declaration block. Which a number of declarations followed

     * by a })].

     */

    private void parseDeclarationBlock() throws IOException {

        for (;;) {

            int token = parseDeclaration();

            switch (token) {

            case END: case BRACE_CLOSE:

                return;

            case BRACKET_CLOSE: case PAREN_CLOSE:

                // Bail

                throw new RuntimeException("Unexpected close in declaration block");

            case IDENTIFIER:

                break;

            }

        }

    }

    /**

     * Parses a single declaration, which is an identifier a : and another

     * identifier. This returns the last token seen.

     */

    // identifier+: identifier* ;|}

    private int parseDeclaration() throws IOException {

        int    token;

        if ((token = parseIdentifiers(':', false)) != IDENTIFIER) {

            return token;

        }

        // Make the property name to lowercase

        for (int counter = unitBuffer.length() - 1; counter >= 0; counter--) {

            unitBuffer.setCharAt(counter, Character.toLowerCase

                                 (unitBuffer.charAt(counter)));

        }

        callback.handleProperty(unitBuffer.toString());

        token = parseIdentifiers(';', true);

        callback.handleValue(unitBuffer.toString());

        return token;

    }

    /**

     * Parses identifiers until <code>extraChar</code> is encountered,

     * returning the ending token, which will be IDENTIFIER if extraChar

     * is found.

     */

    private int parseIdentifiers(char extraChar,

                                 boolean wantsBlocks) throws IOException {

        int   nextToken;

        int   ubl;

        unitBuffer.setLength(0);

        for (;;) {

            nextToken = nextToken(extraChar);

            switch (nextToken) {

            case IDENTIFIER:

                if (tokenBufferLength > 0) {

                    if (tokenBuffer[tokenBufferLength - 1] == extraChar) {

                        if (--tokenBufferLength > 0) {

                            if (readWS && unitBuffer.length() > 0) {

                                unitBuffer.append(' ');

                            }

                            unitBuffer.append(tokenBuffer, 0,

                                              tokenBufferLength);

                        }

                        return IDENTIFIER;

                    }

                    if (readWS && unitBuffer.length() > 0) {

                        unitBuffer.append(' ');

                    }

                    unitBuffer.append(tokenBuffer, 0, tokenBufferLength);

                }

                break;

            case BRACKET_OPEN:

            case BRACE_OPEN:

            case PAREN_OPEN:

                ubl = unitBuffer.length();

                if (wantsBlocks) {

                    unitBuffer.append(charMapping[nextToken]);

                }

                parseTillClosed(nextToken);

                if (!wantsBlocks) {

                    unitBuffer.setLength(ubl);

                }

                break;

            case BRACE_CLOSE:

                // No need to throw for these two, we return token and

                // caller can do whatever.

            case BRACKET_CLOSE:

            case PAREN_CLOSE:

            case END:

                // Hit the end

                return nextToken;

            }

        }

    }

    /**

     * Parses till a matching block close is encountered. This is only

     * appropriate to be called at the top level (no nesting).

     */

    private void parseTillClosed(int openToken) throws IOException {

        int       nextToken;

        boolean   done = false;

        startBlock(openToken);

        while (!done) {

            nextToken = nextToken((char)0);

            switch (nextToken) {

            case IDENTIFIER:

                if (unitBuffer.length() > 0 && readWS) {

                    unitBuffer.append(' ');

                }

                if (tokenBufferLength > 0) {

                    unitBuffer.append(tokenBuffer, 0, tokenBufferLength);

                }

                break;

            case BRACKET_OPEN: case BRACE_OPEN: case PAREN_OPEN:

                if (unitBuffer.length() > 0 && readWS) {

                    unitBuffer.append(' ');

                }

                unitBuffer.append(charMapping[nextToken]);

                startBlock(nextToken);

                break;

            case BRACKET_CLOSE: case BRACE_CLOSE: case PAREN_CLOSE:

                if (unitBuffer.length() > 0 && readWS) {

                    unitBuffer.append(' ');

                }

                unitBuffer.append(charMapping[nextToken]);

                endBlock(nextToken);

                if (!inBlock()) {

                    done = true;

                }

                break;

            case END:

                // Prematurely hit end.

                throw new RuntimeException("Unclosed block");

            }

        }

    }

    /**

     * Fetches the next token.

     */

    private int nextToken(char idChar) throws IOException {

        readWS = false;

        int     nextChar = readWS();

        switch (nextChar) {

        case '\'':

            readTill('\'');

            if (tokenBufferLength > 0) {

                tokenBufferLength--;

            }

            return IDENTIFIER;

        case '"':

            readTill('"');

            if (tokenBufferLength > 0) {

                tokenBufferLength--;

            }

            return IDENTIFIER;

        case '[':

            return BRACKET_OPEN;

        case ']':

            return BRACKET_CLOSE;

        case '{':

            return BRACE_OPEN;

        case '}':

            return BRACE_CLOSE;

        case '(':

            return PAREN_OPEN;

        case ')':

            return PAREN_CLOSE;

        case -1:

            return END;

        default:

            pushChar(nextChar);

            getIdentifier(idChar);

            return IDENTIFIER;

        }

    }

    /**

     * Gets an identifier, returning true if the length of the string is greater than 0,

     * stopping when <code>stopChar</code>, whitespace, or one of {}()[] is

     * hit.

     */

    // NOTE: this could be combined with readTill, as they contain somewhat

    // similar functionality.

    private boolean getIdentifier(char stopChar) throws IOException {

        boolean lastWasEscape = false;

        boolean done = false;

        int escapeCount = 0;

        int escapeChar = 0;

        int nextChar;

        int intStopChar = (int)stopChar;

        // 1 for '\', 2 for valid escape char [0-9a-fA-F], 3 for

        // stop character (white space, ()[]{}) 0 otherwise

        short type;

        int escapeOffset = 0;