/*

 * Copyright (c) 2012,2016, 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 com.sun.tools.javadoc.main;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import com.sun.tools.javadoc.main.JavaScriptScanner.TagParser.Kind;

import static com.sun.tools.javac.util.LayoutCharacters.EOI;

/**

 * Parser to detect use of JavaScript in documentation comments.

 */

public class JavaScriptScanner {

    public static interface Reporter {

        void report();

    }

    static class ParseException extends Exception {

        private static final long serialVersionUID = 0;

        ParseException(String key) {

            super(key);

        }

    }

    private Reporter reporter;

    /** The input buffer, index of most recent character read,

     *  index of one past last character in buffer.

     */

    protected char[] buf;

    protected int bp;

    protected int buflen;

    /** The current character.

     */

    protected char ch;

    private boolean newline = true;

    Map<String, TagParser> tagParsers;

    Set<String> eventAttrs;

    Set<String> uriAttrs;

    public JavaScriptScanner() {

        initTagParsers();

        initEventAttrs();

        initURIAttrs();

    }

    public void parse(String comment, Reporter r) {

        reporter = r;

        String c = comment;

        buf = new char[c.length() + 1];

        c.getChars(0, c.length(), buf, 0);

        buf[buf.length - 1] = EOI;

        buflen = buf.length - 1;

        bp = -1;

        newline = true;

        nextChar();

        blockContent();

        blockTags();

    }

    private void checkHtmlTag(String tag) {

        if (tag.equalsIgnoreCase("script")) {

            reporter.report();

        }

    }

    private void checkHtmlAttr(String name, String value) {

        String n = name.toLowerCase(Locale.ENGLISH);

        if (eventAttrs.contains(n)

                || uriAttrs.contains(n)

                    && value != null && value.toLowerCase(Locale.ENGLISH).trim().startsWith("javascript:")) {

            reporter.report();

        }

    }

    void nextChar() {

        ch = buf[bp < buflen ? ++bp : buflen];

        switch (ch) {

            case '\f': case '\n': case '\r':

                newline = true;

        }

    }

    /**

     * Read block content, consisting of text, html and inline tags.

     * Terminated by the end of input, or the beginning of the next block tag:

     * i.e. @ as the first non-whitespace character on a line.

     */

    @SuppressWarnings("fallthrough")

    protected void blockContent() {

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n': case '\r': case '\f':

                    newline = true;

                    // fallthrough

                case ' ': case '\t':

                    nextChar();

                    break;

                case '&':

                    entity(null);

                    break;

                case '<':

                    html();

                    break;

                case '>':

                    newline = false;

                    nextChar();

                    break;

                case '{':

                    inlineTag(null);

                    break;

                case '@':

                    if (newline) {

                        break loop;

                    }

                    // fallthrough

                default:

                    newline = false;

                    nextChar();

            }

        }

    }

    /**

     * Read a series of block tags, including their content.

     * Standard tags parse their content appropriately.

     * Non-standard tags are represented by {@link UnknownBlockTag}.

     */

    protected void blockTags() {

        while (ch == '@')

            blockTag();

    }

    /**

     * Read a single block tag, including its content.

     * Standard tags parse their content appropriately.

     * Non-standard tags are represented by {@link UnknownBlockTag}.

     */

    protected void blockTag() {

        int p = bp;

        try {

            nextChar();

            if (isIdentifierStart(ch)) {

                String name = readTagName();

                TagParser tp = tagParsers.get(name);

                if (tp == null) {

                    blockContent();

                } else {

                    switch (tp.getKind()) {

                        case BLOCK:

                            tp.parse(p);

                            return;

                        case INLINE:

                            return;

                    }

                }

            }

            blockContent();

        } catch (ParseException e) {

            blockContent();

        }

    }

    protected void inlineTag(Void list) {

        newline = false;

        nextChar();

        if (ch == '@') {

            inlineTag();

        }

    }

    /**

     * Read a single inline tag, including its content.

     * Standard tags parse their content appropriately.

     * Non-standard tags are represented by {@link UnknownBlockTag}.

     * Malformed tags may be returned as {@link Erroneous}.

     */

    protected void inlineTag() {

        int p = bp - 1;

        try {

            nextChar();

            if (isIdentifierStart(ch)) {

                String name = readTagName();

                TagParser tp = tagParsers.get(name);

                if (tp == null) {

                    skipWhitespace();

                    inlineText(WhitespaceRetentionPolicy.REMOVE_ALL);

                    nextChar();

                } else {

                    skipWhitespace();

                    if (tp.getKind() == TagParser.Kind.INLINE) {

                        tp.parse(p);

                    } else { // handle block tags (ex: @see) in inline content

                        inlineText(WhitespaceRetentionPolicy.REMOVE_ALL); // skip content

                        nextChar();

                    }

                }

            }

        } catch (ParseException e) {

        }

    }

    private static enum WhitespaceRetentionPolicy {

        RETAIN_ALL,

        REMOVE_FIRST_SPACE,

        REMOVE_ALL

    }

    /**

     * Read plain text content of an inline tag.

     * Matching pairs of { } are skipped; the text is terminated by the first

     * unmatched }. It is an error if the beginning of the next tag is detected.

     */

    private void inlineText(WhitespaceRetentionPolicy whitespacePolicy) throws ParseException {

        switch (whitespacePolicy) {

            case REMOVE_ALL:

                skipWhitespace();

                break;

            case REMOVE_FIRST_SPACE:

                if (ch == ' ')

                    nextChar();

                break;

            case RETAIN_ALL:

            default:

                // do nothing

                break;

        }

        int pos = bp;

        int depth = 1;

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n': case '\r': case '\f':

                    newline = true;

                    break;

                case ' ': case '\t':

                    break;

                case '{':

                    newline = false;

                    depth++;

                    break;

                case '}':

                    if (--depth == 0) {

                        return;

                    }

                    newline = false;

                    break;

                case '@':

                    if (newline)

                        break loop;

                    newline = false;

                    break;

                default:

                    newline = false;

                    break;

            }

            nextChar();

        }

        throw new ParseException("dc.unterminated.inline.tag");

    }

    /**

     * Read Java class name, possibly followed by member

     * Matching pairs of {@literal < >} are skipped. The text is terminated by the first

     * unmatched }. It is an error if the beginning of the next tag is detected.

     */

    // TODO: boolean allowMember should be enum FORBID, ALLOW, REQUIRE

    // TODO: improve quality of parse to forbid bad constructions.

    // TODO: update to use ReferenceParser

    @SuppressWarnings("fallthrough")

    protected void reference(boolean allowMember) throws ParseException {

        int pos = bp;

        int depth = 0;

        // scan to find the end of the signature, by looking for the first

        // whitespace not enclosed in () or <>, or the end of the tag

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n': case '\r': case '\f':

                    newline = true;

                    // fallthrough

                case ' ': case '\t':

                    if (depth == 0)

                        break loop;

                    break;

                case '(':

                case '<':

                    newline = false;

                    depth++;

                    break;

                case ')':

                case '>':

                    newline = false;

                    --depth;

                    break;

                case '}':

                    if (bp == pos)

                        return;

                    newline = false;

                    break loop;

                case '@':

                    if (newline)

                        break loop;

                    // fallthrough

                default:

                    newline = false;

            }

            nextChar();

        }

        if (depth != 0)

            throw new ParseException("dc.unterminated.signature");

    }

    /**

     * Read Java identifier

     * Matching pairs of { } are skipped; the text is terminated by the first

     * unmatched }. It is an error if the beginning of the next tag is detected.

     */

    @SuppressWarnings("fallthrough")

    protected void identifier() throws ParseException {

        skipWhitespace();

        int pos = bp;

        if (isJavaIdentifierStart(ch)) {

            readJavaIdentifier();

            return;

        }

        throw new ParseException("dc.identifier.expected");

    }

    /**

     * Read a quoted string.

     * It is an error if the beginning of the next tag is detected.

     */

    @SuppressWarnings("fallthrough")

    protected void quotedString() {

        int pos = bp;

        nextChar();

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n': case '\r': case '\f':

                    newline = true;

                    break;

                case ' ': case '\t':

                    break;

                case '"':

                    nextChar();

                    // trim trailing white-space?

                    return;

                case '@':

                    if (newline)

                        break loop;

            }

            nextChar();

        }

    }

    /**

     * Read a term ie. one word.

     * It is an error if the beginning of the next tag is detected.

     */

    @SuppressWarnings("fallthrough")

    protected void inlineWord() {

        int pos = bp;

        int depth = 0;

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n':

                    newline = true;

                    // fallthrough

                case '\r': case '\f': case ' ': case '\t':

                    return;

                case '@':

                    if (newline)

                        break loop;

                case '{':

                    depth++;

                    break;

                case '}':

                    if (depth == 0 || --depth == 0)

                        return;

                    break;

            }

            newline = false;

            nextChar();

        }

    }

    /**

     * Read general text content of an inline tag, including HTML entities and elements.

     * Matching pairs of { } are skipped; the text is terminated by the first

     * unmatched }. It is an error if the beginning of the next tag is detected.

     */

    @SuppressWarnings("fallthrough")

    private void inlineContent() {

        skipWhitespace();

        int pos = bp;

        int depth = 1;

        loop:

        while (bp < buflen) {

            switch (ch) {

                case '\n': case '\r': case '\f':

                    newline = true;

                    // fall through

                case ' ': case '\t':

                    nextChar();

                    break;

                case '&':

                    entity(null);

                    break;

                case '<':

                    newline = false;

                    html();

                    break;

                case '{':

                    newline = false;

                    depth++;

                    nextChar();

                    break;

                case '}':

                    newline = false;

                    if (--depth == 0) {

                        nextChar();

                        return;

                    }

                    nextChar();

                    break;

                case '@':

                    if (newline)

                        break loop;

                    // fallthrough

                default:

                    nextChar();

                    break;

            }

        }

    }

    protected void entity(Void list) {

        newline = false;

        entity();

    }

    /**