/*
 * Copyright (c) 1996, 2014, 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 org.openjdk.asmtools.jasm;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 */
public class TypeAnnotationUtils {


    /*-------------------------------------------------------- */
    /* TypeAnnotationData Inner Classes */
    static public enum PathKind {
        DEEPER_ARRAY            (0, "DEEPER_ARRAY", "ARRAY"),
        DEEPER_NESTEDTYPE       (1, "DEEPER_NESTEDTYPE", "INNER_TYPE"),
        BOUND_WILDCARDTYPE      (2, "BOUND_WILDCARDTYPE", "WILDCARD"),
        ITHARG_PARAMETERTYPE    (3, "ITHARG_PARAMETERTYPE", "TYPE_ARGUMENT");

        private final int key;
        private final String type;
        private final String parseKey;
        public static final int maxLen = 3;

        PathKind(int key, String type, String parseval) {
            this.key = key;
            this.type = type;
            this.parseKey = parseval;
        }

        public int key() {
            return key;
        }

        public String parsekey() {
            return parseKey;
        }

    }

    static private HashMap<String, PathKind> PathTypeHash = new HashMap<>(PathKind.maxLen);

    private static void initPathTypes(PathKind pk) {
        PathTypeHash.put(pk.parseKey, pk);
    }

    static {
        for (PathKind pk : PathKind.values()) {
            initPathTypes(pk);
        }
    }

    public static PathKind pathKind(String parseKey) {
        return PathTypeHash.get(parseKey);
    }

    // will throw ArrayIndexOutOfBounds if i < 0 or i > 3
    static public PathKind getPathKind(int i) {
        return PathKind.values()[i];
    }

    /*-------------------------------------------------------- */
    /* TypeAnnotationData Inner Classes */
    static public class TypePathEntry {

        private final PathKind kind;
        private final char index;

        public TypePathEntry(int kind, char index) {
            this.kind = getPathKind(kind);
            this.index = index;
        }

        public PathKind kind() {
            return kind;
        }

        public char index() {
            return index;
        }

        public String toString() {
            return kind.parsekey() + "(" + index + ")";
        }

    }

  /*-------------------------------------------------------- */
  /* TypeAnnotationData Inner Classes */
    static public enum InfoType {
        TYPEPARAM           ("TYPEPARAM", "TYPEPARAM"),
        SUPERTYPE           ("SUPERTYPE", "SUPERTYPE"),
        TYPEPARAM_BOUND     ("TYPEPARAM_BOUND", "TYPEPARAM_BOUND"),
        EMPTY               ("EMPTY", "EMPTY"),
        METHODPARAM         ("METHODPARAM", "METHODPARAM"),
        EXCEPTION           ("EXCEPTION", "EXCEPTION"),
        LOCALVAR            ("LOCALVAR", "LOCALVAR"),
        CATCH               ("CATCH", "CATCH"),
        OFFSET              ("OFFSET", "OFFSET"),
        TYPEARG             ("TYPEARG", "TYPEARG");

        private final String parseKey;
        private final String printval;

        InfoType(String parse, String print) {
            parseKey = parse;
            printval = print;
        }

        public String parseKey() {
            return parseKey;
        }

    }

    /**
     * TargetType
     *
     * A (typed) tag (constant) representing the type of Annotation Target.
     */
    static public enum TargetType {
        class_type_param            (0x00, "CLASS_TYPE_PARAMETER",  InfoType.TYPEPARAM, "class type parameter"),
        meth_type_param             (0x01, "METHOD_TYPE_PARAMETER",  InfoType.TYPEPARAM, "method type parameter"),
        class_exts_impls            (0x10, "CLASS_EXTENDS",  InfoType.SUPERTYPE, "class extends/implements"),
        class_type_param_bnds       (0x11, "CLASS_TYPE_PARAMETER_BOUND",  InfoType.TYPEPARAM_BOUND, "class type parameter bounds"),
        meth_type_param_bnds        (0x12, "METHOD_TYPE_PARAMETER_BOUND",  InfoType.TYPEPARAM_BOUND, "method type parameter bounds"),
        field                       (0x13, "FIELD",  InfoType.EMPTY, "field"),
        meth_ret_type               (0x14, "METHOD_RETURN",  InfoType.EMPTY, "method return type"),
        meth_reciever               (0x15, "METHOD_RECEIVER",  InfoType.EMPTY, "method reciever"),
        meth_formal_param           (0x16, "METHOD_FORMAL_PARAMETER",  InfoType.METHODPARAM, "method formal parameter type"),
        throws_type                 (0x17, "THROWS",  InfoType.EXCEPTION, "exception type in throws"),
        local_var                   (0x40, "LOCAL_VARIABLE",  InfoType.LOCALVAR, "local variable"),
        resource_var                (0x41, "RESOURCE_VARIABLE",  InfoType.LOCALVAR, "resource variable"),                     // TODO
        exception_param             (0x42, "EXCEPTION_PARAM",  InfoType.CATCH, "exception parameter"),                   // TODO
        type_test                   (0x43, "INSTANCEOF",  InfoType.OFFSET, "type test (instanceof)"),
        obj_creat                   (0x44, "NEW",  InfoType.OFFSET, "object creation (new)"),
        constr_ref_receiver         (0x45, "CONSTRUCTOR_REFERENCE_RECEIVER", InfoType.OFFSET, "constructor reference receiver"),
        meth_ref_receiver           (0x46, "METHOD_REFERENCE_RECEIVER", InfoType.OFFSET, "method reference receiver"),
        cast                        (0x47, "CAST",  InfoType.TYPEARG, "cast"),
        constr_invoc_typearg        (0x48, "CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT",  InfoType.TYPEARG, "type argument in constructor call"),
        meth_invoc_typearg          (0x49, "METHOD_INVOCATION_TYPE_ARGUMENT", InfoType.TYPEARG, "type argument in method call"),
        constr_ref_typearg          (0x4A, "CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT", InfoType.TYPEARG, "type argument in constructor reference"),
        meth_ref_typearg            (0x4B, "METHOD_REFERENCE_TYPE_ARGUMENT",  InfoType.TYPEARG, "type argument in method reference");

        public static final int maxTag = 0x9A;
        public static final int maxLen = 36;

        public final int value;
        private final String parseKey;
        private final InfoType infoKey;
        private final String printval;

        TargetType(int val, String parse, InfoType info, String print) {
            value = val;
            parseKey = parse;
            infoKey = info;
            printval = print;
        }

        public String parseKey() {
            return parseKey;
        }

        public String infoKey() {
            return infoKey.parseKey();
        }

        public InfoType infoType() {
            return infoKey;
        }

        public void print(PrintWriter out) {
            out.print(parseKey);
        }

        @Override
        public String toString() {
            return parseKey + " (" + infoKey() + ") <" + printval + "> [" + Integer.toHexString(value) + "]";
        }
    };

    static private HashMap<String, TargetType> TargetTypeHash = new HashMap<>(TargetType.maxLen);
    static private HashMap<Integer, TargetType> TargetTypeList = new HashMap<>(TargetType.maxLen);

    private static void initTargetTypes(TypeAnnotationUtils.TargetType tt) {
        TargetTypeList.put(tt.value, tt);
        TargetTypeHash.put(tt.parseKey, tt);
    }

    static {
        for (TargetType type : TargetType.values()) {
            initTargetTypes(type);
        }
    }

    public static TargetType targetType(String parseKey) {
        return TargetTypeHash.get(parseKey);
    }

    public static TargetType targetTypeEnum(Integer typeCode) {
        return TargetTypeList.get(typeCode);
    }

    /**
     * TargetInfo
     *
     * BaseClass for any Type Annotation Target-Info.
     */
    public static class TargetInfo {

        protected TargetType targettype = null;

        public TargetInfo(TargetType tt) {
            targettype = tt;
        }

        public TargetType getTargetType() {
            return targettype;
        }

        public void print(PrintWriter out, String tab) {
            // print the TargetType and TargetInfo
            out.print(tab + " {");
            targettype.print(out);
            _print(out, tab);
            out.print(tab + "}");
        }

        public void _print(PrintWriter out, String tab) {
            // sub-classes override
        }

        public void write(CheckedDataOutputStream out) throws IOException {
            // placeholder
        }

        public int getLength() {
            return 0;
        }

        @Override
        public String toString() {
            return toString(0);
        }

        protected void _toString(StringBuilder sb, int tabLevel) {
            // sub-classes override
        }

        public String toString(int tabLevel) {
            StringBuilder sb = new StringBuilder();
            String tabStr = tabString(tabLevel);

            // first print the name/target-type
            sb.append(tabStr);
            sb.append(targettype.infoKey() + " \n");
            sb.append(tabStr);
            sb.append(targettype + " \n");

            // get the sub-classes parts
            _toString(sb, tabLevel);

            return sb.toString();
        }

        protected static String tabString(int tabLevel) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < tabLevel; i++) {
                sb.append('\t');
            }

            return sb.toString();
        }

    }

    /**
     * TypeParams_Target (3.3.1 Type parameters)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class typeparam_target extends TargetInfo {

        int pindex;

        public typeparam_target(TargetType tt, int indx) {
            super(tt);
            pindex = indx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte(pindex);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(pindex);
        }

        @Override
        public int getLength() {
            return 1 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("param_index: ");
            sb.append(pindex);
            sb.append('\n');
        }
    }

    /**
     * supertype_target (3.3.2 Class extends and implements)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class supertype_target extends TargetInfo {

        int type_index;

        public supertype_target(TargetType tt, int tindex) {
            super(tt);
            type_index = tindex;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(type_index);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(type_index);
        }

        @Override
        public int getLength() {
            return 2 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("type_index: ");
            sb.append(type_index);
            sb.append('\n');
        }
    }

    /**
     * typeparam_bound_target (3.3.3 Type parameter bounds)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class typeparam_bound_target extends TargetInfo {

        int pindex;
        int bindex;

        public typeparam_bound_target(TargetType tt, int pindx, int bindx) {
            super(tt);
            pindex = pindx;
            bindex = bindx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte(pindex);
            out.writeByte(bindex);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(pindex);
            out.print(" ");
            out.print(bindex);
        }

        @Override
        public int getLength() {
            return 2 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("param_index: ");
            sb.append(pindex);
            sb.append('\n');

            sb.append(tabStr);
            sb.append("bound_index: ");
            sb.append(bindex);
            sb.append('\n');
        }
    }

    /**
     * empty_target (3.3.4 )
     *
     * Types without arguments.
     *
     * Basic types without arguments, like field, method return, or method receiver.
     */
    public static class empty_target extends TargetInfo {

        public empty_target(TargetType tt) {
            super(tt);
        }
    }

    /**
     * methodformalparam_target (3.3.5 Method parameters)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class methodformalparam_target extends TargetInfo {

        int index;

        public methodformalparam_target(TargetType tt, int indx) {
            super(tt);
            index = indx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte(index);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(index);
        }

        @Override
        public int getLength() {
            return 1 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("index: ");
            sb.append(index);
            sb.append('\n');
        }
    }

    /**
     * throws_target (3.3.6 throws clauses)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class throws_target extends TargetInfo {

        int type_index;

        public throws_target(TargetType tt, int tindex) {
            super(tt);
            type_index = tindex;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(type_index);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(type_index);
        }

        @Override
        public int getLength() {
            return 2 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("type_index: ");
            sb.append(type_index);
            sb.append('\n');
        }
    }

    /**
     * localvar_target (3.3.7 Local variables)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class localvar_target extends TargetInfo {

        public static class LocalVar_Entry {

            public int startPC;
            public int length;
            public int cpx;

            public LocalVar_Entry(int st, int len, int index) {
                startPC = st;
                length = len;
                cpx = index;
            }

            void write(CheckedDataOutputStream out) throws IOException {
                out.writeShort(startPC);
                out.writeShort(length);
                out.writeShort(cpx);
            }

            public void _print(PrintWriter out, String tab) {
                out.print(tab + "{");
                out.print(startPC);
                out.print(" ");
                out.print(length);
                out.print(" ");
                out.print(cpx);
                out.println("}");
            }

            public String toString() {
                return new String("startPC: " + startPC
                        + "  length: " + length
                        + "  cpx: " + cpx);
            }
        }

        ArrayList<LocalVar_Entry> table = null;

        public localvar_target(TargetType tt, int size) {
            super(tt);
            table = new ArrayList<>(size);
        }

        public void addEntry(int startPC, int length, int cpx) {
            LocalVar_Entry entry = new LocalVar_Entry(startPC, length, cpx);
            table.add(entry);
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(table.size());
            for (LocalVar_Entry entry : table) {
                entry.write(out);
            }
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            String innerTab = tab + "          ";
            out.println();
            for (LocalVar_Entry entry : table) {
                entry._print(out, innerTab);
            }
            out.print(innerTab);
        }

        @Override
        public int getLength() {
            return 2 + // U2 for table size
                    (6 * table.size()) + // (3 * U2) for each table entry
                    super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr1 = tabString(tabLevel + 1);
            int i = 1;
            for (LocalVar_Entry entry : table) {
                sb.append(tabStr1);
                sb.append("[" + i + "]: ");
                sb.append(entry.toString());
                sb.append('\n');
                i += 1;
            }
        }
    }

    /**
     * catch_target (3.3.8 Exception parameters (catch clauses))
     *
     * Index to the exception type (the type that shows up in a catch clause).
     *
     * These need location information to identify the annotated element.
     */
    public static class catch_target extends TargetInfo {

        int exception_table_index;

        public catch_target(TargetType tt, int indx) {
            super(tt);
            exception_table_index = indx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(exception_table_index);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(exception_table_index);
        }

        @Override
        public int getLength() {
            return 2 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("exception_table_index: ");
            sb.append(exception_table_index);
            sb.append('\n');
        }
    }

    /**
     * offset_target (3.3.9 Typecasts, type tests, and object creation)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class offset_target extends TargetInfo {

        int offset;

        public offset_target(TargetType tt, int ofst) {
            super(tt);
            offset = ofst;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(offset);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(offset);
        }

        @Override
        public int getLength() {
            return 2 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("offset: ");
            sb.append(offset);
            sb.append('\n');
        }
    }

    /**
     * typearg_target (3.3.10 Constructor and method call type arguments)
     *
     * BaseClass for any Type Annotation Target-Info that is in a parameterized type,
     * array, or nested type.
     *
     * These need location information to identify the annotated element.
     */
    public static class typearg_target extends TargetInfo {

        int offset;
        int typeIndex;

        public typearg_target(TargetType tt, int ofst, int tindx) {
            super(tt);
            offset = ofst;
            typeIndex = tindx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeShort(offset);
            out.writeByte(typeIndex);
            super.write(out);
        }

        @Override
        public void _print(PrintWriter out, String tab) {
            out.print(" ");
            out.print(offset);
            out.print(" ");
            out.print(typeIndex);
        }

        @Override
        public int getLength() {
            return 3 + super.getLength();
        }

        @Override
        protected void _toString(StringBuilder sb, int tabLevel) {
            String tabStr = tabString(tabLevel);
            sb.append(tabStr);
            sb.append("offset: ");
            sb.append(offset);
            sb.append('\n');

            sb.append(tabStr);
            sb.append("type_index: ");
            sb.append(typeIndex);
            sb.append('\n');
        }
    }

    /*-------------------------------------------------------- */
    /* TypeAnnotationVisitor Methods */
    public static class TypeAnnotationTargetVisitor {

        public final void visit(TargetType tt) {
            switch (tt) {
                case class_type_param:
                case meth_type_param:
                    visit_type_param_target(tt);
                    break;
                case class_exts_impls:
                    visit_supertype_target(tt);
                    break;
                case class_type_param_bnds:
                case meth_type_param_bnds:
                    visit_typeparam_bound_target(tt);
                    break;
                case field:
                case meth_ret_type:
                case meth_reciever:
                    visit_empty_target(tt);
                    break;
                case meth_formal_param:
                    visit_methodformalparam_target(tt);
                    break;
                case throws_type:
                    visit_throws_target(tt);
                    break;
                case local_var:
                case resource_var:
                    visit_localvar_target(tt);
                    break;
                case exception_param:
                    visit_catch_target(tt);
                    break;
                case type_test:
                case obj_creat:
                case constr_ref_receiver:
                case meth_ref_receiver:
                    visit_offset_target(tt);
                    break;

                case cast:
                case constr_invoc_typearg:
                case meth_invoc_typearg:
                case constr_ref_typearg:
                case meth_ref_typearg:

                    visit_typearg_target(tt);
                    break;
            }
        }

        public void visit_type_param_target(TargetType tt) {
        }

        public void visit_supertype_target(TargetType tt) {
        }

        public void visit_typeparam_bound_target(TargetType tt) {
        }

        public void visit_empty_target(TargetType tt) {
        }

        public void visit_methodformalparam_target(TargetType tt) {
        }

        public void visit_throws_target(TargetType tt) {
        }

        public void visit_localvar_target(TargetType tt) {
        }

        public void visit_catch_target(TargetType tt) {
        }

        public void visit_offset_target(TargetType tt) {
        }

        public void visit_typearg_target(TargetType tt) {
        }
    }

    /*-------------------------------------------------------- */

    /*-------------------------------------------------------- */
    /* TypeAnnotationData Methods */
    public TypeAnnotationUtils() {
    }

    public static TargetType getTargetType(int tt_index) {
        if (tt_index < 0 || tt_index > TargetType.maxTag) {
            return null;
        }
        return TargetTypeList.get(tt_index);
    }

    static public TargetType getTargetType(String tt) {
        TargetType retval = TargetTypeHash.get(tt);

        if (retval.name().equals("UNUSED")) {
            retval = null;
        }

        return retval;
    }

}