/*
 * Copyright (c) 2010, 2015, 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     6945418 6993978 8006694 7196160 8129962
 * @summary Project Coin: Simplified Varargs Method Invocation
 *  temporarily workaround combo tests are causing time out in several platforms
 * @library /tools/javac/lib
 * @modules jdk.compiler/com.sun.tools.javac.api
 *          jdk.compiler/com.sun.tools.javac.code
 *          jdk.compiler/com.sun.tools.javac.comp
 *          jdk.compiler/com.sun.tools.javac.main
 *          jdk.compiler/com.sun.tools.javac.tree
 *          jdk.compiler/com.sun.tools.javac.util
 * @build combo.ComboTestHelper
 * @run main Warn4
 */

import java.io.IOException;
import java.util.Set;
import java.util.HashSet;
import javax.tools.Diagnostic;
import javax.tools.Diagnostic.Kind;
import javax.tools.JavaFileObject;

import combo.ComboInstance;
import combo.ComboParameter;
import combo.ComboTask.Result;
import combo.ComboTestHelper;

public class Warn4 extends ComboInstance<Warn4> {

    final static Warning[] error = null;
    final static Warning[] none = new Warning[] {};
    final static Warning[] vararg = new Warning[] { Warning.VARARGS };
    final static Warning[] unchecked = new Warning[] { Warning.UNCHECKED };
    final static Warning[] both = new Warning[] { Warning.VARARGS, Warning.UNCHECKED };

    enum Warning {
        UNCHECKED("generic.array.creation"),
        VARARGS("varargs.non.reifiable.type");

        String key;

        Warning(String key) {
            this.key = key;
        }

        boolean isSuppressed(TrustMe trustMe, SourceLevel source,
                SuppressLevel suppressLevelClient,
                SuppressLevel suppressLevelDecl,
                ModifierKind modKind) {
            switch(this) {
                case VARARGS:
                    return source.compareTo(SourceLevel.JDK_7) < 0 ||
                            suppressLevelDecl == SuppressLevel.UNCHECKED ||
                            trustMe == TrustMe.TRUST;
                case UNCHECKED:
                    return suppressLevelClient == SuppressLevel.UNCHECKED ||
                        (trustMe == TrustMe.TRUST &&
                         (((modKind == ModifierKind.FINAL || modKind == ModifierKind.STATIC) &&
                           source.compareTo( SourceLevel.JDK_7) >= 0 ) ||
                          (modKind == ModifierKind.PRIVATE && source.compareTo( SourceLevel.JDK_9) >= 0 )));
            }

            SuppressLevel supLev = this == VARARGS ?
                suppressLevelDecl :
                suppressLevelClient;
            return supLev == SuppressLevel.UNCHECKED ||
                    (trustMe == TrustMe.TRUST && modKind != ModifierKind.NONE);
        }
    }

    enum SourceLevel {
        JDK_6("6"),
        JDK_7("7"),
        JDK_9("9");

        String sourceKey;

        SourceLevel(String sourceKey) {
            this.sourceKey = sourceKey;
        }
    }

    enum TrustMe implements ComboParameter {
        DONT_TRUST(""),
        TRUST("@java.lang.SafeVarargs");

        String anno;

        TrustMe(String anno) {
            this.anno = anno;
        }

        @Override
        public String expand(String optParameter) {
            return anno;
        }
    }

    enum ModifierKind implements ComboParameter {
        NONE(" "),
        FINAL("final "),
        STATIC("static "),
        PRIVATE("private ");

        String mod;

        ModifierKind(String mod) {
            this.mod = mod;
        }

        @Override
        public String expand(String optParameter) {
            return mod;
        }
    }

    enum SuppressLevel implements ComboParameter {
        NONE(""),
        UNCHECKED("unchecked");

        String lint;

        SuppressLevel(String lint) {
            this.lint = lint;
        }

        @Override
        public String expand(String optParameter) {
            return "@SuppressWarnings(\"" + lint + "\")";
        }
    }

    enum Signature implements ComboParameter {
        UNBOUND("void #NAME(List<?>#ARITY arg) { #BODY }",
            new Warning[][] {none, none, none, none, error}),
        INVARIANT_TVAR("<Z> void #NAME(List<Z>#ARITY arg) { #BODY }",
            new Warning[][] {both, both, error, both, error}),
        TVAR("<Z> void #NAME(Z#ARITY arg) { #BODY }",
            new Warning[][] {both, both, both, both, vararg}),
        INVARIANT("void #NAME(List<String>#ARITY arg) { #BODY }",
            new Warning[][] {error, error, error, both, error}),
        UNPARAMETERIZED("void #NAME(String#ARITY arg) { #BODY }",
            new Warning[][] {error, error, error, error, none});

        String template;
        Warning[][] warnings;

        Signature(String template, Warning[][] warnings) {
            this.template = template;
            this.warnings = warnings;
        }

        boolean isApplicableTo(Signature other) {
            return warnings[other.ordinal()] != null;
        }

        boolean giveUnchecked(Signature other) {
            return warnings[other.ordinal()] == unchecked ||
                    warnings[other.ordinal()] == both;
        }

        boolean giveVarargs(Signature other) {
            return warnings[other.ordinal()] == vararg ||
                    warnings[other.ordinal()] == both;
        }

        @Override
        public String expand(String optParameter) {
            if (optParameter.equals("CLIENT")) {
                return template.replaceAll("#ARITY", "")
                        .replaceAll("#NAME", "test")
                        .replaceAll("#BODY", "m(arg)");
            } else {
                return template.replaceAll("#ARITY", "...")
                        .replaceAll("#NAME", "m")
                        .replaceAll("#BODY", "");
            }
        }
    }

    public static void main(String... args) {
        new ComboTestHelper<Warn4>()
                .withFilter(Warn4::badTestFilter)
                .withDimension("SOURCE", (x, level) -> x.sourceLevel = level, SourceLevel.values())
                .withDimension("TRUSTME", (x, trustme) -> x.trustMe = trustme, TrustMe.values())
                .withArrayDimension("SUPPRESS", (x, suppress, idx) -> x.suppress[idx] = suppress, 2, SuppressLevel.values())
                .withDimension("MOD", (x, mod) -> x.modKind = mod, ModifierKind.values())
                .withArrayDimension("MTH", (x, sig, idx) -> x.sigs[idx] = sig, 2, Signature.values())
                .run(Warn4::new);
    }

    SourceLevel sourceLevel;
    TrustMe trustMe;
    SuppressLevel[] suppress = new SuppressLevel[2];
    ModifierKind modKind;
    Signature[] sigs = new Signature[2];

    boolean badTestFilter() {
        return sigs[0].isApplicableTo(sigs[1]);
    }

    final String template = "import java.util.List;\n" +
                            "class Test {\n" +
                            "   #{TRUSTME} #{SUPPRESS[0]} #{MOD} #{MTH[0].VARARG}\n" +
                            "   #{SUPPRESS[1]} #{MTH[1].CLIENT}\n" +
                            "}";

    @Override
    public void doWork() throws IOException {
        check(newCompilationTask()
                .withOption("-Xlint:unchecked")
                .withOption("-source")
                .withOption(sourceLevel.sourceKey)
                .withSourceFromTemplate(template)
                .analyze());
    }

    void check(Result<?> res) {
        boolean[] warnArr = new boolean[] {sigs[0].giveUnchecked(sigs[1]),
                               sigs[0].giveVarargs(sigs[1])};

        Set<Warning> warnings = new HashSet<>();
        for (Diagnostic<? extends JavaFileObject> d : res.diagnosticsForKind(Kind.MANDATORY_WARNING)) {
            if (d.getCode().contains(Warning.VARARGS.key)) {
                    warnings.add(Warning.VARARGS);
            } else if(d.getCode().contains(Warning.UNCHECKED.key)) {
                warnings.add(Warning.UNCHECKED);
            }
        }

        boolean badOutput = false;
        for (Warning wkind : Warning.values()) {
            boolean isSuppressed = wkind.isSuppressed(trustMe, sourceLevel,
                    suppress[1], suppress[0], modKind);
            badOutput |= (warnArr[wkind.ordinal()] && !isSuppressed) !=
                    warnings.contains(wkind);
        }
        if (badOutput) {
            fail("invalid diagnostics for source:\n" +
                    res.compilationInfo() +
                    "\nExpected unchecked warning: " + warnArr[0] +
                    "\nExpected unsafe vararg warning: " + warnArr[1] +
                    "\nWarnings: " + warnings +
                    "\nSource level: " + sourceLevel);
        }
    }
}
