/*

 * 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.javac.parser;

import java.text.BreakIterator;

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.source.doctree.AttributeTree.ValueKind;

import com.sun.tools.javac.parser.DocCommentParser.TagParser.Kind;

import com.sun.tools.javac.parser.Tokens.Comment;

import com.sun.tools.javac.parser.Tokens.TokenKind;

import com.sun.tools.javac.tree.DCTree;

import com.sun.tools.javac.tree.DCTree.DCAttribute;

import com.sun.tools.javac.tree.DCTree.DCDocComment;

import com.sun.tools.javac.tree.DCTree.DCEndElement;

import com.sun.tools.javac.tree.DCTree.DCErroneous;

import com.sun.tools.javac.tree.DCTree.DCIdentifier;

import com.sun.tools.javac.tree.DCTree.DCReference;

import com.sun.tools.javac.tree.DCTree.DCStartElement;

import com.sun.tools.javac.tree.DCTree.DCText;

import com.sun.tools.javac.tree.DocTreeMaker;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.util.DiagnosticSource;

import com.sun.tools.javac.util.List;

import com.sun.tools.javac.util.ListBuffer;

import com.sun.tools.javac.util.Log;

import com.sun.tools.javac.util.Name;

import com.sun.tools.javac.util.Names;

import com.sun.tools.javac.util.Options;

import com.sun.tools.javac.util.Position;

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

/**

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class DocCommentParser {

    static class ParseException extends Exception {

        private static final long serialVersionUID = 0;

        ParseException(String key) {

            super(key);

        }

    }

    final ParserFactory fac;

    final DiagnosticSource diagSource;

    final Comment comment;

    final DocTreeMaker m;

    final Names names;

    BreakIterator sentenceBreaker;

    /** 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;

    int textStart = -1;

    int lastNonWhite = -1;

    boolean newline = true;

    Map<Name, TagParser> tagParsers;

    DocCommentParser(ParserFactory fac, DiagnosticSource diagSource, Comment comment) {

        this.fac = fac;

        this.diagSource = diagSource;

        this.comment = comment;

        names = fac.names;

        m = fac.docTreeMaker;

        Locale locale = (fac.locale == null) ? Locale.getDefault() : fac.locale;

        Options options = fac.options;

        boolean useBreakIterator = options.isSet("breakIterator");

        if (useBreakIterator || !locale.getLanguage().equals(Locale.ENGLISH.getLanguage()))

            sentenceBreaker = BreakIterator.getSentenceInstance(locale);

        initTagParsers();

    }

    DCDocComment parse() {

        String c = comment.getText();

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

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

        buf[buf.length - 1] = EOI;

        buflen = buf.length - 1;

        bp = -1;

        nextChar();

        List<DCTree> body = blockContent();

        List<DCTree> tags = blockTags();

        // split body into first sentence and body

        ListBuffer<DCTree> fs = new ListBuffer<DCTree>();

        loop:

        for (; body.nonEmpty(); body = body.tail) {

            DCTree t = body.head;

            switch (t.getKind()) {

                case TEXT:

                    String s = ((DCText) t).getBody();

                    int i = getSentenceBreak(s);

                    if (i > 0) {

                        int i0 = i;

                        while (i0 > 0 && isWhitespace(s.charAt(i0 - 1)))

                            i0--;

                        fs.add(m.at(t.pos).Text(s.substring(0, i0)));

                        int i1 = i;

                        while (i1 < s.length() && isWhitespace(s.charAt(i1)))

                            i1++;

                        body = body.tail;

                        if (i1 < s.length())

                            body = body.prepend(m.at(t.pos + i1).Text(s.substring(i1)));

                        break loop;

                    } else if (body.tail.nonEmpty()) {

                        if (isSentenceBreak(body.tail.head)) {

                            int i0 = s.length() - 1;

                            while (i0 > 0 && isWhitespace(s.charAt(i0)))

                                i0--;

                            fs.add(m.at(t.pos).Text(s.substring(0, i0 + 1)));

                            body = body.tail;

                            break loop;

                        }

                    }

                    break;

                case START_ELEMENT:

                case END_ELEMENT:

                    if (isSentenceBreak(t))

                        break loop;

                    break;

            }

            fs.add(t);

        }

        @SuppressWarnings("unchecked")

        DCTree first = getFirst(fs.toList(), body, tags);

        int pos = (first == null) ? Position.NOPOS : first.pos;

        DCDocComment dc = m.at(pos).DocComment(comment, fs.toList(), body, tags);

        return dc;

    }

    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 List<DCTree> blockContent() {

        ListBuffer<DCTree> trees = new ListBuffer<DCTree>();

        textStart = -1;

        loop:

        while (bp < buflen) {

            switch (ch) {

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

                    newline = true;

                    // fallthrough

                case ' ': case '\t':

                    nextChar();

                    break;

                case '&':

                    entity(trees);

                    break;

                case '<':

                    newline = false;

                    addPendingText(trees, bp - 1);

                    trees.add(html());

                    if (textStart == -1) {

                        textStart = bp;

                        lastNonWhite = -1;

                    }

                    break;

                case '>':

                    newline = false;

                    addPendingText(trees, bp - 1);

                    trees.add(m.at(bp).Erroneous(newString(bp, bp+1), diagSource, "dc.bad.gt"));

                    nextChar();

                    if (textStart == -1) {

                        textStart = bp;

                        lastNonWhite = -1;

                    }

                    break;

                case '{':

                    inlineTag(trees);

                    break;

                case '@':

                    if (newline) {

                        addPendingText(trees, lastNonWhite);

                        break loop;

                    }

                    // fallthrough

                default:

                    newline = false;

                    if (textStart == -1)

                        textStart = bp;

                    lastNonWhite = bp;

                    nextChar();

            }

        }

        if (lastNonWhite != -1)

            addPendingText(trees, lastNonWhite);

        return trees.toList();

    }

    /**

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

     * Standard tags parse their content appropriately.

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

     */

    protected List<DCTree> blockTags() {

        ListBuffer<DCTree> tags = new ListBuffer<DCTree>();

        while (ch == '@')

            tags.add(blockTag());

        return tags.toList();

    }

    /**

     * Read a single block tag, including its content.

     * Standard tags parse their content appropriately.

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

     */

    protected DCTree blockTag() {

        int p = bp;

        try {

            nextChar();

            if (isIdentifierStart(ch)) {

                TagParser tp = tagParsers.get(name);

                if (tp == null) {

                    List<DCTree> content = blockContent();

                    return m.at(p).UnknownBlockTag(name, content);

                } else {

                    switch (tp.getKind()) {

                        case BLOCK:

                            return tp.parse(p);

                        case INLINE:

                            return erroneous("dc.bad.inline.tag", p);

                    }

                }

            }

            blockContent();

            return erroneous("dc.no.tag.name", p);

        } catch (ParseException e) {

            blockContent();

            return erroneous(e.getMessage(), p);

        }

    }

    protected void inlineTag(ListBuffer<DCTree> list) {

        newline = false;

        nextChar();

        if (ch == '@') {

            addPendingText(list, bp - 2);

            list.add(inlineTag());

            textStart = bp;

            lastNonWhite = -1;

        } else {

            if (textStart == -1)

                textStart = bp - 1;

            lastNonWhite = bp;

        }

    }

    /**

     * 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 DCTree inlineTag() {

        int p = bp - 1;

        try {

            nextChar();

            if (isIdentifierStart(ch)) {

                skipWhitespace();

                TagParser tp = tagParsers.get(name);

                if (tp == null) {

                    DCTree text = inlineText();

                    if (text != null) {

                        nextChar();

                        return m.at(p).UnknownInlineTag(name, List.of(text));

                    }

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

                    DCTree tree =  tp.parse(p);

                    if (tree != null) {

                        return tree;

                    }

                } else {

                    inlineText(); // skip content

                    nextChar();

                }

            }

            return erroneous("dc.no.tag.name", p);

        } catch (ParseException e) {

            return erroneous(e.getMessage(), p);

        }

    }

    /**

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

     */

    protected DCTree inlineText() throws ParseException {

        skipWhitespace();

        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;

                    lastNonWhite = bp;

                    depth++;

                    break;

                case '}':

                    if (--depth == 0) {

                        return m.at(pos).Text(newString(pos, bp));

                    }

                    newline = false;

                    lastNonWhite = bp;

                    break;

                case '@':

                    if (newline)

                        break loop;

                    newline = false;

                    lastNonWhite = bp;

                    break;

                default:

                    newline = false;

                    lastNonWhite = bp;

                    break;

            }

            nextChar();

        }

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

    }

    /**

     * Read Java class name, possibly followed by member

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

     */

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

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

    @SuppressWarnings("fallthrough")

    protected DCReference 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 null;

                    newline = false;

                    break loop;

                case '@':

                    if (newline)

                        break loop;

                    // fallthrough

                default:

                    newline = false;

            }

            nextChar();

        }

        if (depth != 0)

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

        String sig = newString(pos, bp);

        // Break sig apart into qualifiedExpr member paramTypes.

        JCTree qualExpr;

        Name member;

        List<JCTree> paramTypes;

        Log.DeferredDiagnosticHandler deferredDiagnosticHandler

                = new Log.DeferredDiagnosticHandler(fac.log);

        try {

            int hash = sig.indexOf("#");

            int lparen = sig.indexOf("(", hash + 1);

            if (hash == -1) {

                if (lparen == -1) {

                    qualExpr = parseType(sig);

                    member = null;

                } else {

                    qualExpr = null;

                    member = parseMember(sig.substring(0, lparen));

                }

            } else {

                qualExpr = (hash == 0) ? null : parseType(sig.substring(0, hash));

                if (lparen == -1)

                    member = parseMember(sig.substring(hash + 1));

                else

                    member = parseMember(sig.substring(hash + 1, lparen));

            }

            if (lparen < 0) {

                paramTypes = null;

            } else {

                int rparen = sig.indexOf(")", lparen);

                if (rparen != sig.length() - 1)

                    throw new ParseException("dc.ref.bad.parens");

                paramTypes = parseParams(sig.substring(lparen + 1, rparen));

            }

            if (!deferredDiagnosticHandler.getDiagnostics().isEmpty())

                throw new ParseException("dc.ref.syntax.error");

        } finally {

            fac.log.popDiagnosticHandler(deferredDiagnosticHandler);

        }

        return m.at(pos).Reference(sig, qualExpr, member, paramTypes);

    }

    JCTree parseType(String s) throws ParseException {

        JavacParser p = fac.newParser(s, false, false, false);

        JCTree tree = p.parseType();

        if (p.token().kind != TokenKind.EOF)

            throw new ParseException("dc.ref.unexpected.input");

        return tree;

    }

    Name parseMember(String s) throws ParseException {

        JavacParser p = fac.newParser(s, false, false, false);

        Name name = p.ident();

        if (p.token().kind != TokenKind.EOF)

            throw new ParseException("dc.ref.unexpected.input");

        return name;