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

/*
 * @test
 * @bug 7101822
 * @summary static import fails to resolve interfaces on nested enums via import statements
 */

import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class TestLazyImportScope {

    static int checkCount = 0;

    enum ImportOrder {
        NORMAL("import a.C.D;\n" +
               "#I"),
        REVERSE("#I\n" +
               "import a.C.D;");

        String importLayout;

        ImportOrder(String importLayout) {
            this.importLayout = importLayout;
        }

        String getImportString(ImportKind ik) {
            return importLayout.replaceAll("#I", ik.importStr);
        }
    }

    enum ImportKind {
        NAMED("import a.A.B.E;"),
        ON_DEMAND("import a.A.B.*;"),
        STATIC_NAMED_TYPE("import static a.A.B.E;"),
        STATIC_NAMED_MEMBER("import static a.A.B.bm;"),
        STATIC_ON_DEMAND("import static a.A.B.*;");

        String importStr;

        private ImportKind(String importStr) {
            this.importStr = importStr;
        }
    }

    enum TypeRefKind {
        NONE(""),
        E("E e = null;"),
        F("F f = null;"),
        BOTH("E e = null; F f = null;");

        String typeRefStr;

        private TypeRefKind(String typeRefStr) {
            this.typeRefStr = typeRefStr;
        }

        boolean isImported(ImportKind ik) {
            switch (ik) {
                case NAMED:
                case STATIC_NAMED_TYPE: return this == NONE || this == E;
                case ON_DEMAND:
                case STATIC_ON_DEMAND: return true;
                default: return this == NONE;
            }
        }
    }

    enum MemberRefKind {
        NONE(""),
        FIELD("Object o = bf;"),
        METHOD("bm();"),
        BOTH("Object o = bf; bm();");

        String memberRefStr;

        private MemberRefKind(String memberRefStr) {
            this.memberRefStr = memberRefStr;
        }

        boolean isImported(ImportKind ik) {
            switch (ik) {
                case STATIC_NAMED_MEMBER: return this == NONE || this == METHOD;
                case STATIC_ON_DEMAND: return true;
                default: return this == NONE;
            }
        }
    }

    public static void main(String... args) throws Exception {

        //create default shared JavaCompiler - reused across multiple compilations
        JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);

        for (ImportOrder ord : ImportOrder.values()) {
            for (ImportKind ik : ImportKind.values()) {
                for (TypeRefKind tk : TypeRefKind.values()) {
                    for (MemberRefKind mk : MemberRefKind.values()) {
                        new TestLazyImportScope(ord, ik, tk, mk).run(comp, fm);
                    }
                }
            }
        }
        System.out.println("Total check executed: " + checkCount);
    }

    ImportOrder ord;
    ImportKind ik;
    TypeRefKind tk;
    MemberRefKind mk;
    JavaSource source;
    DiagnosticChecker diagChecker;

    TestLazyImportScope(ImportOrder ord, ImportKind ik, TypeRefKind tk, MemberRefKind mk) {
        this.ord = ord;
        this.ik = ik;
        this.tk = tk;
        this.mk = mk;
        this.source = new JavaSource();
        this.diagChecker = new DiagnosticChecker();
    }

    class JavaSource extends SimpleJavaFileObject {

        String bodyTemplate = "package a;\n" +
                              "#I\n" +
                              "class A {\n" +
                              "   static class B extends D {\n" +
                              "      static class E { }\n" +
                              "      static class F { }\n" +
                              "      static Object bf;\n" +
                              "      static void bm() { }\n" +
                              "   }\n" +
                              "}\n" +
                              "class C {\n" +
                              "   static class D { }\n" +
                              "}\n" +
                              "class Test {\n" +
                              "   void test() {\n" +
                              "      #T\n" +
                              "      #M\n" +
                              "   }\n" +
                              "}";

        String source;

        public JavaSource() {
            super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
            source = bodyTemplate.replaceAll("#I", ord.getImportString(ik))
                    .replaceAll("#T", tk.typeRefStr)
                    .replaceAll("#M", mk.memberRefStr);
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return source;
        }
    }

    void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
        JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
                null, null, Arrays.asList(source));
        try {
            ct.analyze();
        } catch (Throwable ex) {
            throw new AssertionError("Error thrown when compiling the following code:\n" + source.getCharContent(true));
        }
        check();
    }

    void check() {
        checkCount++;

        boolean errorExpected = !tk.isImported(ik) || !mk.isImported(ik);

        if (errorExpected != diagChecker.errorFound) {
            throw new Error("invalid diagnostics for source:\n" +
                source.getCharContent(true) +
                "\nFound error: " + diagChecker.errorFound +
                "\nExpected error: " + errorExpected);
        }
    }

    static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {

        boolean errorFound;

        public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
            if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
                errorFound = true;
            }
        }
    }
}