/*

 * Copyright (c) 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.

 */

import com.sun.tools.classfile.*;

import java.io.IOException;

import java.lang.annotation.Repeatable;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Stream;

import static java.lang.String.format;

import static java.util.stream.Collectors.*;

public abstract class LocalVariableTestBase extends TestBase {

    public static final int DEFAULT_SCOPE = 0;

    private final ClassFile classFile;

    private final Class<?> clazz;

    public LocalVariableTestBase(Class<?> clazz) {

        this.clazz = clazz;

        try {

            this.classFile = ClassFile.read(getClassFile(clazz));

        } catch (IOException | ConstantPoolException e) {

            throw new IllegalArgumentException("Can't read classfile for specified class", e);

        }

    }

    public void test() throws IOException {

        List<java.lang.reflect.Method> testMethods = Stream.of(clazz.getDeclaredMethods())

                .filter(m -> m.getAnnotationsByType(ExpectedLocals.class).length > 0)

                .collect(toList());

        int failed = 0;

        for (java.lang.reflect.Method method : testMethods) {

            try {

                Map<String, String> expectedLocals2Types = new HashMap<>();

                Map<String, Integer> sig2scope = new HashMap<>();

                for (ExpectedLocals anno : method.getDeclaredAnnotationsByType(ExpectedLocals.class)) {

                    expectedLocals2Types.put(anno.name(), anno.type());

                    sig2scope.put(anno.name() + "&" + anno.type(), anno.scope());

                }

                test(method.getName(), expectedLocals2Types, sig2scope);

            } catch (AssertionFailedException ex) {

                System.err.printf("Test %s failed.%n", method.getName());

                ex.printStackTrace();

                failed++;

            }

        }

        if (failed > 0)

            throw new RuntimeException(format("Failed %d out of %d. See logs.", failed, testMethods.size()));

    }

    public void test(String methodName, Map<String, String> expectedLocals2Types, Map<String, Integer> sig2scope)

            throws IOException {

        for (Method m : classFile.methods) {

            String mName = getString(m.name_index);

            if (methodName.equals(mName)) {

                System.out.println("Testing local variable table in method " + mName);

                Code_attribute code_attribute = (Code_attribute) m.attributes.get(Attribute.Code);

                List<? extends VariableTable> variableTables = getVariableTables(code_attribute);

                generalLocalVariableTableCheck(variableTables);

                List<VariableTable.Entry> entries = variableTables.stream()

                        .flatMap(table -> table.entries().stream())

                        .collect(toList());

                generalEntriesCheck(entries, code_attribute);

                assertIndexesAreUnique(entries, sig2scope);

                checkNamesAndTypes(entries, expectedLocals2Types);

                checkDoubleAndLongIndexes(entries, sig2scope, code_attribute.max_locals);

            }

        }

    }

    private void generalLocalVariableTableCheck(List<? extends VariableTable> variableTables) {

        for (VariableTable localTable : variableTables) {

            //only one per variable.

            assertEquals(localTable.localVariableTableLength(),

                    localTable.entries().size(), "Incorrect local variable table length");

            //attribute length is offset(line_number_table_length) + element_size*element_count

            assertEquals(localTable.attributeLength(),

                    2 + (5 * 2) * localTable.localVariableTableLength(), "Incorrect attribute length");

        }

    }

    private void generalEntriesCheck(List<VariableTable.Entry> entries, Code_attribute code_attribute) {

        for (VariableTable.Entry e : entries) {

            assertTrue(e.index() >= 0 && e.index() < code_attribute.max_locals,

                    "Index " + e.index() + " out of variable array. Size of array is " + code_attribute.max_locals);

            assertTrue(e.startPC() >= 0, "StartPC is less then 0. StartPC = " + e.startPC());

            assertTrue(e.length() >= 0, "Length is less then 0. Length = " + e.length());

            assertTrue(e.startPC() + e.length() <= code_attribute.code_length,

                    format("StartPC+Length > code length.%n" +

                            "%s%n" +

                            "code_length = %s"

                            , e, code_attribute.code_length));

        }

    }

    private void checkNamesAndTypes(List<VariableTable.Entry> entries,

                                    Map<String, String> expectedLocals2Types) {

        Map<String, List<String>> actualNames2Types = entries.stream()

                .collect(

                        groupingBy(VariableTable.Entry::name,

                                mapping(VariableTable.Entry::type, toList())));

        for (Map.Entry<String, String> name2type : expectedLocals2Types.entrySet()) {

            String name = name2type.getKey();

            String type = name2type.getValue();

            assertTrue(actualNames2Types.containsKey(name),

                    format("There is no record for local variable %s%nEntries: %s", name, entries));

            assertTrue(actualNames2Types.get(name).contains(type),

                    format("Types are different for local variable %s%nExpected type: %s%nActual type: %s",

                            name, type, actualNames2Types.get(name)));

        }

    }

    private void assertIndexesAreUnique(Collection<VariableTable.Entry> entries, Map<String, Integer> scopes) {

        //check every scope separately

        Map<Object, List<VariableTable.Entry>> entriesByScope = groupByScope(entries, scopes);

        for (Map.Entry<Object, List<VariableTable.Entry>> mapEntry : entriesByScope.entrySet()) {

            mapEntry.getValue().stream()

                    .collect(groupingBy(VariableTable.Entry::index))

                    .entrySet()

                    .forEach(e ->

                            assertTrue(e.getValue().size() == 1,

                                    "Multiple variables point to the same index in common scope. " + e.getValue()));

        }

    }

    private void checkDoubleAndLongIndexes(Collection<VariableTable.Entry> entries,

                                           Map<String, Integer> scopes, int maxLocals) {

        //check every scope separately

        Map<Object, List<VariableTable.Entry>> entriesByScope = groupByScope(entries, scopes);

        for (List<VariableTable.Entry> entryList : entriesByScope.values()) {

            Map<Integer, VariableTable.Entry> index2Entry = entryList.stream()

                    .collect(toMap(VariableTable.Entry::index, e -> e));

            entryList.stream()

                    .filter(e -> "J".equals(e.type()) || "D".equals(e.type()))

                    .forEach(e -> {

                        assertTrue(e.index() + 1 < maxLocals,

                                format("Index %s is out of variable array. Long and double occupy 2 cells." +

                                        " Size of array is %d", e.index() + 1, maxLocals));

                        assertTrue(!index2Entry.containsKey(e.index() + 1),

                                format("An entry points to the second cell of long/double entry.%n%s%n%s", e,

                                        index2Entry.get(e.index() + 1)));

                    });

        }

    }

    private Map<Object, List<VariableTable.Entry>> groupByScope(

            Collection<VariableTable.Entry> entries, Map<String, Integer> scopes) {

        return entries.stream().collect(groupingBy(e -> scopes.getOrDefault(e.name() + "&" + e.type(), DEFAULT_SCOPE)));

    }

    protected String getString(int i) {

        try {

            return classFile.constant_pool.getUTF8Info(i).value;

        } catch (ConstantPool.InvalidIndex | ConstantPool.UnexpectedEntry ex) {

            ex.printStackTrace();

            throw new AssertionFailedException("Issue while reading constant pool");

        }

    }

    interface VariableTable {

        int localVariableTableLength();

        List<VariableTable.Entry> entries();

        int attributeLength();

        interface Entry {

            int index();

            int startPC();

            int length();

            String name();

            String type();

            default String dump() {

                return format("Entry{" +

                        "%n    name    = %s" +

                        "%n    type    = %s" +

                        "%n    index   = %d" +

                        "%n    startPC = %d" +

                        "%n    length  = %d" +

                        "%n}", name(), type(), index(), startPC(), length());

            }

        }

    }

    @Retention(RetentionPolicy.RUNTIME)

    @Repeatable(Container.class)

    @interface ExpectedLocals {

        String name();

        String type();

        int scope() default DEFAULT_SCOPE;

    }

    @Retention(RetentionPolicy.RUNTIME)

    @interface Container {

        ExpectedLocals[] value();

    }

}