/*

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

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

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

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;

/**

 *  A utility class to parse a string in a doc comment containing a

 *  reference to an API element, such as a type, field or method.

 *

 *  <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 ReferenceParser {

    /**

     * An object to contain the result of parsing a reference to an API element.

     * Any, but not all, of the member fields may be null.

     */

    static public class Reference {

        /** The type, if any, in the signature. */

        public final JCTree qualExpr;

        /** The member name, if any, in the signature. */

        public final Name member;

        /** The parameter types, if any, in the signature. */

        public final List<JCTree> paramTypes;

        Reference(JCTree qualExpr, Name member, List<JCTree> paramTypes) {

            this.qualExpr = qualExpr;

            this.member = member;

            this.paramTypes = paramTypes;

        }

    }

    /**

     * An exception that indicates an error occurred while parsing a signature.

     */

    static public class ParseException extends Exception {

        private static final long serialVersionUID = 0;

        ParseException(String message) {

            super(message);

        }

    }

    private final ParserFactory fac;

    /**

     * Create a parser object to parse reference signatures.

     * @param fac a factory for parsing Java source code.

     */

    public ReferenceParser(ParserFactory fac) {

        this.fac = fac;

    }

    /**

     * Parse a reference to an API element as may be found in doc comment.

     * @param sig the signature to be parsed

     * @return a {@code Reference} object containing the result of parsing the signature

     * @throws ParseException if there is an error while parsing the signature

     */

    public Reference parse(String sig) throws ParseException {

        // 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 new Reference(qualExpr, member, paramTypes);

    }

    private 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;

    }

    private 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;

    }

    private List<JCTree> parseParams(String s) throws ParseException {

        if (s.trim().isEmpty())

            return List.nil();

        JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);

        ListBuffer<JCTree> paramTypes = new ListBuffer<>();

        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)

            p.nextToken();

        while (p.token().kind == TokenKind.COMMA) {

            p.nextToken();

            paramTypes.add(p.parseType());

            if (p.token().kind == TokenKind.IDENTIFIER)

                p.nextToken();

        }

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

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

        return paramTypes.toList();

    }

}