/*
 * Copyright (c) 2014, 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.
 *
 * 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 propertiesparser.parser;

/**
 * Common interface to all kinds of diagnostic argument types.
 */
public interface MessageType {

    /**
     * Visitor method.
     */
    <R, A> R accept(Visitor<R, A> v, A a);

    /**
     * The type as mentioned in the resource file.
     */
    String kindName();

    /**
     * A custom type is a type for which a predefined alternative does not exist. As such, it is an
     * handy option when prototyping - but usages of custom types should be avoided in product-quality
     * resource file comments.
     *
     * Example: 'com.sun.tools.javac.code.Flags.Flag'
     */
    public static class CustomType implements MessageType {

        /** The string-based representation of this type. */
        public String typeString;

        public CustomType(String typeString) {
            this.typeString = typeString;
        }

        @Override
        public String kindName() {
            return typeString;
        }

        @Override
        public <R, A> R accept(Visitor<R, A> v, A a) {
            return v.visitCustomType(this, a);
        }
    }

    /**
     * A predefined type. All common types mentioned in the resource file comments are meant to
     * be included here.
     */
    public enum SimpleType implements MessageType {

        BOOLEAN("boolean", "boolean", null),
        FRAGMENT("fragment", "Fragment", null),
        DIAGNOSTIC("diagnostic", "JCDiagnostic", "com.sun.tools.javac.util"),
        MODIFIER("modifier", "Modifier", "javax.lang.model.element"),
        FILE("file", "File", "java.io"),
        FILE_OBJECT("file object", "JavaFileObject", "javax.tools"),
        PATH("path", "Path", "java.nio.file"),
        NAME("name", "Name", "com.sun.tools.javac.util"),
        NUMBER("number", "int", null),
        OPTION_NAME("option name", "Option", "com.sun.tools.javac.main"),
        SOURCE_VERSION("source version", "Source", "com.sun.tools.javac.code"),
        STRING("string", "String", null),
        SYMBOL("symbol", "Symbol", "com.sun.tools.javac.code"),
        SYMBOL_KIND("symbol kind", "Kind", "com.sun.tools.javac.code.Kinds"),
        KIND_NAME("kind name", "KindName", "com.sun.tools.javac.code.Kinds"),
        TOKEN("token", "TokenKind", "com.sun.tools.javac.parser.Tokens"),
        TYPE("type", "Type", "com.sun.tools.javac.code"),
        SET("set", "Set", "java.util"),
        LIST("list", "List", "java.util"),
        OBJECT("object", "Object", null),
        UNUSED("unused", "Void", null),
        UNKNOWN("<unknown>", "UnknownType", null);

        /** name of the predefined type as mentioned in the resource file. */
        public final String kindName;

        /** string-based representation of the type */
        public final String clazz;

        /** type qualifier (might be null) */
        public final String qualifier;

        SimpleType(String kindName, String clazz, String qualifier) {
            this.kindName = kindName;
            this.clazz = clazz;
            this.qualifier = qualifier;
        }

        @Override
        public String kindName() {
            return kindName;
        }

        @Override
        public <R, A> R accept(Visitor<R, A> v, A a) {
            return v.visitSimpleType(this, a);
        }
    }

    /**
     * A compound type is a collection of some element type.
     *
     * Example: list of string
     */
    public static class CompoundType implements MessageType {

        /**
         * Compound type kind.
         */
        public enum Kind {
            LIST("list of", SimpleType.LIST),
            SET("set of", SimpleType.SET);

            public final String kindName;
            public final SimpleType clazz;

            Kind(String kindName, SimpleType clazz) {
                this.kindName = kindName;
                this.clazz = clazz;
            }
        }

        /** The compound type kind. */
        public final Kind kind;

        /** The element type. */
        public final MessageType elemtype;

        public CompoundType(Kind kind, MessageType elemtype) {
            this.kind = kind;
            this.elemtype = elemtype;
        }

        @Override
        public String kindName() {
            return kind.kindName;
        }

        @Override
        public <R, A> R accept(Visitor<R, A> v, A a) {
            return v.visitCompoundType(this, a);
        }
    }

    /**
     * A union type represents an alternative between two (or more) types. It can be useful to
     * define the type of an argument which can assume multiple (unrelated) values; union types
     * are only meant to be used in cases where the alternative comes up frequently enough in the
     * resource file comments - in order to avoid cluttered comments.
     *
     * Example: message segment
     */
    public static class UnionType implements MessageType {

        /**
         * Union type kind.
         */
        public enum Kind {
            MESSAGE_SEGMENT("message segment", SimpleType.DIAGNOSTIC, SimpleType.FRAGMENT),
            FILE_NAME("file name", SimpleType.FILE, SimpleType.FILE_OBJECT);

            final String kindName;
            final SimpleType[] choices;

            Kind(String kindName, SimpleType... choices) {
                this.kindName = kindName;
                this.choices = choices;
            }
        }

        /** The union type kind. */
        public final Kind kind;

        /** The union type alternatives. */
        public final MessageType[] choices;

        UnionType(Kind kind) {
            this(kind, kind.choices);
        }

        protected UnionType(Kind kind, MessageType[] choices) {
            this.choices = choices;
            this.kind = kind;
        }

        @Override
        public String kindName() {
            return kind.kindName;
        }

        @Override
        public <R, A> R accept(Visitor<R, A> v, A a) {
            return v.visitUnionType(this, a);
        }
    }

    /**
     * A subclass of union type representing 'explicit' alternatives in the resource file comments.
     * Note: as the token 'or' is parsed with lowest priority, it is not possible, for instance,
     * to form a compound type out of an 'or' type. In such cases a plain union type should be used
     * instead.
     *
     * Examples: symbol or type
     */
    public static class OrType extends UnionType {

        public static final String OR_NAME = "or";

        @Override
        public String kindName() {
            return OR_NAME;
        }

        public OrType(MessageType... choices) {
            super(null, choices);
        }
    }

    /**
     * Visitor class.
     */
    public static abstract class Visitor<R, A> {
        public abstract R visitCustomType(CustomType t, A a);
        public abstract R visitSimpleType(SimpleType t, A a);
        public abstract R visitCompoundType(CompoundType t, A a);
        public abstract R visitUnionType(UnionType t, A a);
    }
}