/*

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

 * @summary Ensure all methods of PlatformProvider are called correctly, and their result is used

 *          correctly.

 * @library /tools/lib

 * @build ToolBox PlatformProviderTest

 * @run main/othervm PlatformProviderTest

 */

import java.io.IOException;

import java.io.Writer;

import java.lang.reflect.Field;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.Processor;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.annotation.processing.SupportedOptions;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.TypeElement;

import javax.tools.JavaCompiler;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

import com.sun.source.util.JavacTask;

import com.sun.source.util.Plugin;

import com.sun.tools.javac.platform.PlatformDescription;

import com.sun.tools.javac.platform.PlatformProvider;

import com.sun.tools.javac.util.Log;

public class PlatformProviderTest implements PlatformProvider {

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

        new PlatformProviderTest().run();

    }

    void run() throws IOException {

        Path registration = Paths.get(System.getProperty("test.classes"),

                                      "META-INF",

                                      "services",

                                      "com.sun.tools.javac.platform.PlatformProvider");

        Files.createDirectories(registration.getParent());

        try (Writer metaInf = Files.newBufferedWriter(registration)) {

            metaInf.write(PlatformProviderTest.class.getName());

        }

        doTest("name", "");

        doTest("name:param", "param");

        doTestFailure();

    }

    void doTest(String platformSpec, String expectedParameter) {

        ToolBox tb = new ToolBox();

        ToolBox.Result result =

                tb.new JavacTask(ToolBox.Mode.EXEC)

                  .options("-J-classpath",

                           "-J" + System.getProperty("test.classes"),

                           "-XDrawDiagnostics",

                           "-release",

                           platformSpec,

                           System.getProperty("test.src") + "/PlatformProviderTestSource.java")

                  .run();

        List<String> expectedOutput =

                Arrays.asList("getSupportedPlatformNames",

                              "getPlatform(name, " + expectedParameter + ")",

                              "getSourceVersion",

                              "getTargetVersion",

                              "getPlatformPath",

                              "testPlugin: [testPluginKey=testPluginValue]",

                              "process: {testAPKey=testAPValue}",

                              "process: {testAPKey=testAPValue}",

                              "PlatformProviderTestSource.java:4:49: compiler.warn.raw.class.use: java.util.ArrayList, java.util.ArrayList<E>",

                              "compiler.misc.count.warn",

                              "close");

        List<String> actualOutput = result.getOutputLines(ToolBox.OutputKind.STDERR);

        result.writeAll();

        if (!expectedOutput.equals(actualOutput)) {

            throw new AssertionError(  "Expected output: " + expectedOutput +

                                     "; actual output: " + actualOutput);

        }

        result.writeAll();

    }

    void doTestFailure() {

        ToolBox tb = new ToolBox();

        ToolBox.Result result =

                tb.new JavacTask(ToolBox.Mode.EXEC)

                  .options("-J-classpath",

                           "-J" + System.getProperty("test.classes"),

                           "-release",

                           "fail",

                           System.getProperty("test.src") + "/PlatformProviderTestSource.java")

                  .run(ToolBox.Expect.FAIL);

        List<String> expectedOutput =

                Arrays.asList("getSupportedPlatformNames",

                              "getPlatform(fail, )",

                              "javac: javac.err.unsupported.release.version",

                              "javac.msg.usage");

        List<String> actualOutput = result.getOutputLines(ToolBox.OutputKind.STDERR);

        result.writeAll();

        if (!expectedOutput.equals(actualOutput)) {

            throw new AssertionError(  "Expected output: " + expectedOutput +

                                     "; actual output: " + actualOutput);

        }

        result.writeAll();

    }

    @Override

    public Iterable<String> getSupportedPlatformNames() {

        System.err.println("getSupportedPlatformNames");

        return Arrays.asList("name", "fail");

    }

    @Override

    public PlatformDescription getPlatform(String platformName, String options) throws PlatformNotSupported {

        System.err.println("getPlatform(" + platformName + ", " + options + ")");

        if ("fail".equals(platformName)) {

            throw new PlatformNotSupported();

        }

        return new DescriptionImpl();

    }

    static {

        try {

            Field useRawMessages = Log.class.getDeclaredField("useRawMessages");

            useRawMessages.setAccessible(true);

            useRawMessages.set(null, true);

        } catch (Exception ex) {

            throw new IllegalStateException(ex);

        }

    }

    class DescriptionImpl implements PlatformDescription {

        private final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        private final StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null);

        @Override

        public Collection<Path> getPlatformPath() {

            System.err.println("getPlatformPath");

            List<Path> result = new ArrayList<>();

            fm.getLocationAsPaths(StandardLocation.PLATFORM_CLASS_PATH).forEach(p -> { result.add(p); });

            return result;

        }

        @Override

        public String getSourceVersion() {

            System.err.println("getSourceVersion");

            return "8";

        }

        @Override

        public String getTargetVersion() {

            System.err.println("getTargetVersion");

            return "8";

        }

        @Override

        public List<PluginInfo<Processor>> getAnnotationProcessors() {

            return Arrays.asList(new PluginInfo<Processor>() {

                @Override

                public String getName() {

                    return "test";

                }

                @Override

                public Map<String, String> getOptions() {

                    return Collections.singletonMap("testAPKey", "testAPValue");

                }

                @Override

                public Processor getPlugin() {

                    return new ProcessorImpl();

                }

            });

        }

        @Override

        public List<PluginInfo<Plugin>> getPlugins() {

            return Arrays.asList(new PluginInfo<Plugin>() {

                @Override

                public String getName() {

                    return "testPlugin";

                }

                @Override

                public Map<String, String> getOptions() {

                    return Collections.singletonMap("testPluginKey", "testPluginValue");

                }

                @Override

                public Plugin getPlugin() {

                    return new PluginImpl();

                }

            });

        }

        @Override

        public List<String> getAdditionalOptions() {

            return Arrays.asList("-Xlint:rawtypes", "-XDrawDiagnostics");

        }

        @Override

        public void close() throws IOException {

            System.err.println("close");

            fm.close();

        }

    }

    @SupportedAnnotationTypes("*")

    @SupportedOptions("testAPKey")

    class ProcessorImpl extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            System.err.println("process: " + processingEnv.getOptions());

            return true;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    class PluginImpl implements Plugin {

        @Override

        public String getName() {

            return "testPluginName";

        }

        @Override

        public void init(JavacTask task, String... args) {

            System.err.println("testPlugin: " + Arrays.toString(args));

        }

    }

}