/*

 * Copyright (c) 2019, 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 8226585

 * @summary Verify behavior w.r.t. preview feature API errors and warnings

 * @library /tools/lib /tools/javac/lib

 * @modules

 *      java.base/jdk.internal

 *      jdk.compiler/com.sun.tools.javac.api

 *      jdk.compiler/com.sun.tools.javac.file

 *      jdk.compiler/com.sun.tools.javac.main

 *      jdk.compiler/com.sun.tools.javac.util

 * @build toolbox.ToolBox toolbox.JavacTask

 * @build combo.ComboTestHelper

 * @compile --enable-preview -source ${jdk.version} PreviewErrors.java

 * @run main/othervm --enable-preview PreviewErrors

 */

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import combo.ComboInstance;

import combo.ComboParameter;

import combo.ComboTask;

import combo.ComboTestHelper;

import java.util.Arrays;

import java.util.Set;

import java.util.stream.Collectors;

import javax.tools.Diagnostic;

import jdk.internal.PreviewFeature;

import toolbox.JavacTask;

import toolbox.ToolBox;

public class PreviewErrors extends ComboInstance<PreviewErrors> {

    protected ToolBox tb;

    PreviewErrors() {

        super();

        tb = new ToolBox();

    }

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

        new ComboTestHelper<PreviewErrors>()

                .withDimension("ESSENTIAL", (x, essential) -> x.essential = essential, EssentialAPI.values())

                .withDimension("PREVIEW", (x, preview) -> x.preview = preview, Preview.values())

                .withDimension("LINT", (x, lint) -> x.lint = lint, Lint.values())

                .withDimension("SUPPRESS", (x, suppress) -> x.suppress = suppress, Suppress.values())

                .withDimension("FROM", (x, from) -> x.from = from, PreviewFrom.values())

                .run(PreviewErrors::new);

    }

    private EssentialAPI essential;

    private Preview preview;

    private Lint lint;

    private Suppress suppress;

    private PreviewFrom from;

    @Override

    public void doWork() throws IOException {

        Path base = Paths.get(".");

        Path src = base.resolve("src");

        Path srcJavaBase = src.resolve("java.base");

        Path classes = base.resolve("classes");

        Path classesJavaBase = classes.resolve("java.base");

        Files.createDirectories(classesJavaBase);

        String previewAPI = """

                            package preview.api;

                            public class Extra {

                                @jdk.internal.PreviewFeature(feature=jdk.internal.PreviewFeature.Feature.${preview}

                                                             ${essential})

                                public static void test() { }

                                @jdk.internal.PreviewFeature(feature=jdk.internal.PreviewFeature.Feature.${preview}

                                                             ${essential})

                                public static class Clazz {}

                            }

                            """.replace("${preview}", PreviewFeature.Feature.values()[0].name())

                               .replace("${essential}", essential.expand(null));

         if (from == PreviewFrom.CLASS) {

            tb.writeJavaFiles(srcJavaBase, previewAPI);

            new JavacTask(tb)

                    .outdir(classesJavaBase)

                    .options("--patch-module", "java.base=" + srcJavaBase.toString())

                    .files(tb.findJavaFiles(srcJavaBase))

                    .run()

                    .writeAll();

         }

        ComboTask task = newCompilationTask()

                .withSourceFromTemplate("""

                                        package test;

                                        public class Test {

                                            #{SUPPRESS}

                                            public void test() {

                                                preview.api.Extra.test();

                                                preview.api.Extra.Clazz c;

                                            }

                                        }

                                        """)

                .withOption("-XDrawDiagnostics")

                .withOption("-source")

                .withOption(String.valueOf(Runtime.version().feature()));

        if (from == PreviewFrom.CLASS) {

            task.withOption("--patch-module")

                .withOption("java.base=" + classesJavaBase.toString())

                .withOption("--add-exports")

                .withOption("java.base/preview.api=ALL-UNNAMED");

        } else {

            task.withSourceFromTemplate("Extra", previewAPI)

                .withOption("--add-exports")

                .withOption("java.base/jdk.internal=ALL-UNNAMED");

        }

        if (preview.expand(null)!= null) {

            task = task.withOption(preview.expand(null));

        }

        if (lint.expand(null) != null) {

            task = task.withOption(lint.expand(null));

        }

        task.generate(result -> {

                Set<String> actual = Arrays.stream(Diagnostic.Kind.values())

                                            .flatMap(kind -> result.diagnosticsForKind(kind).stream())

                                            .map(d -> d.getLineNumber() + ":" + d.getColumnNumber() + ":" + d.getCode())

                                            .collect(Collectors.toSet());

                Set<String> expected;

                boolean ok;

                if (essential == EssentialAPI.YES) {

                    if (preview == Preview.YES) {

                        if (suppress == Suppress.YES) {

                            expected = Set.of();

                        } else if (lint == Lint.ENABLE_PREVIEW) {

                            expected = Set.of("5:26:compiler.warn.is.preview", "6:26:compiler.warn.is.preview");

                        } else {

                            expected = Set.of("-1:-1:compiler.note.preview.filename",

                                              "-1:-1:compiler.note.preview.recompile");

                        }

                        ok = true;

                    } else {

                        expected = Set.of("5:26:compiler.err.is.preview", "6:26:compiler.err.is.preview");

                        ok = false;

                    }

                } else {

                    if (suppress == Suppress.YES) {

                        expected = Set.of();

                    } else if ((preview == Preview.YES && (lint == Lint.NONE || lint == Lint.DISABLE_PREVIEW)) ||

                               (preview == Preview.NO && lint == Lint.DISABLE_PREVIEW)) {

                        expected = Set.of("-1:-1:compiler.note.preview.filename",

                                          "-1:-1:compiler.note.preview.recompile");

                    } else {

                        expected = Set.of("5:26:compiler.warn.is.preview", "6:26:compiler.warn.is.preview");

                    }

                    ok = true;

                }

                if (ok) {

                    if (!result.get().iterator().hasNext()) {

                        throw new IllegalStateException("Did not succeed as expected." + actual);

                    }

                } else {

                    if (result.get().iterator().hasNext()) {

                        throw new IllegalStateException("Succeed unexpectedly.");

                    }

                }

                if (!expected.equals(actual)) {

                    throw new IllegalStateException("Unexpected output for " + essential + ", " + preview + ", " + lint + ", " + suppress + ", " + from + ": actual: \"" + actual + "\", expected: \"" + expected + "\"");

                }

            });

    }

    public enum EssentialAPI implements ComboParameter {

        YES(", essentialAPI=true"),

        NO(", essentialAPI=false");

        private final String code;

        private EssentialAPI(String code) {

            this.code = code;

        }

        public String expand(String optParameter) {

            return code;

        }

    }

    public enum Preview implements ComboParameter {

        YES("--enable-preview"),

        NO(null);

        private final String opt;

        private Preview(String opt) {

            this.opt = opt;

        }

        public String expand(String optParameter) {

            return opt;

        }

    }

    public enum Lint implements ComboParameter {

        NONE(null),

        ENABLE_PREVIEW("-Xlint:preview"),

        DISABLE_PREVIEW("-Xlint:-preview");

        private final String opt;

        private Lint(String opt) {

            this.opt = opt;

        }

        public String expand(String optParameter) {

            return opt;

        }

    }

    public enum Suppress implements ComboParameter {

        YES("@SuppressWarnings(\"preview\")"),

        NO("");

        private final String code;

        private Suppress(String code) {

            this.code = code;

        }

        public String expand(String optParameter) {

            return code;

        }

    }

    public enum PreviewFrom implements ComboParameter {

        CLASS,

        SOURCE;

        private PreviewFrom() {

        }

        public String expand(String optParameter) {

            throw new IllegalStateException();

        }

    }

}