/*
 * Copyright (c) 2016, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package build.tools.module;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import build.tools.module.GenModuleInfoSource.Statement;

/**
 * Sanity test for GenModuleInfoSource tool
 */
public class ModuleInfoExtraTest {
    private static final Path DIR = Paths.get("test");
    public static void main(String... args) throws Exception {
        if (args.length != 0)
            GenModuleInfoSource.verbose = true;

        ModuleInfoExtraTest test = new ModuleInfoExtraTest("m", "m1", "m2", "m3");
        test.run();
    }

    String[] moduleInfo = new String[] {
        "exports p",
        "to",
        "   // comment",
        "   /* comment */ m1",
        ",",
        "m2,m3",
        "   ;",
        "exports q to m1;",
        "provides s with /* ",
        "  comment */ impl     ;    // comment",
        "provides s1",
        "    with  ",
        "    impl1, impl2;"
    };

    String[] moduleInfoExtra = new String[] {
        "exports q",
        "to",
        "   m2 // comment",
        "   /* comment */;",
        "   ;",
        "opens p.q ",
        "   to /* comment */ m3",
        "   , // m1",
        "   /* comment */, m4;",
        "provides s1 with impl3;"
    };

    String[] test1 = new String[] {
        "exports p1 to m1;",
        "exports p2"
    };

    String[] test2 = new String[] {
        "exports to m1;"
    };

    String[] test3 = new String[]{
        "exports p3 to m1;",
        "    m2, m3;"
    };

    String[] test4 = new String[]{
        "provides s with impl1;",   // typo ; should be ,
        "   impl2, impl3;"
    };

    String[] test5 = new String[]{
        "uses s3",
        "provides s3 with impl1,",
        "   impl2, impl3;"
    };

    final Builder builder;
    ModuleInfoExtraTest(String name, String... modules) {
        this.builder = new Builder(name).modules(modules);
    }

    void run() throws IOException {
        testModuleInfo();
        errorCases();
    }


    void testModuleInfo() throws IOException {
        GenModuleInfoSource source = builder.sourceFile(moduleInfo).build();
        Set<String> targetsP = new HashSet<>();
        targetsP.add("m1");
        targetsP.add("m2");
        targetsP.add("m3");

        Set<String> targetsQ = new HashSet<>();
        targetsQ.add("m1");

        Set<String> providerS = new HashSet<>();
        providerS.add("impl");

        Set<String> providerS1 = new HashSet<>();
        providerS1.add("impl1");
        providerS1.add("impl2");

        Set<String> opensPQ = new HashSet<>();

        check(source, targetsP, targetsQ, opensPQ, providerS, providerS1);

        // augment with extra
        Path file = DIR.resolve("extra");
        Files.write(file, Arrays.asList(moduleInfoExtra));
        source = builder.build(file);

        targetsQ.add("m2");
        providerS1.add("impl3");

        opensPQ.add("m3");
        check(source, targetsP, targetsQ, opensPQ, providerS, providerS1);
    }

    void check(GenModuleInfoSource source,
               Set<String> targetsP,
               Set<String> targetsQ,
               Set<String> opensPQ,
               Set<String> providerS,
               Set<String> providerS1) {
        source.moduleInfo.print(new PrintWriter(System.out, true));
        Statement export = source.moduleInfo.exports.get("p");
        if (!export.targets.equals(targetsP)) {
            throw new Error("unexpected: " + export);
        }

        export = source.moduleInfo.exports.get("q");
        if (!export.targets.equals(targetsQ)) {
            throw new Error("unexpected: " + export);
        }

        Statement provides = source.moduleInfo.provides.get("s");
        if (!provides.targets.equals(providerS)) {
            throw new Error("unexpected: " + provides);
        }

        provides = source.moduleInfo.provides.get("s1");
        if (!provides.targets.equals(providerS1)) {
            throw new Error("unexpected: " + provides);
        }
    }



    void errorCases() throws IOException {
        fail(test1);
        fail(test2);
        fail(test3);
        fail(test4);
        fail(test5);
    }

    void fail(String... extras) throws IOException {
        Path file = DIR.resolve("test1");
        Files.write(file, Arrays.asList(extras));
        try {
            builder.build(file);
        } catch (RuntimeException e) {
            if (!e.getMessage().matches("test/test1, line .* is malformed.*") &&
                !e.getMessage().matches("test/test1, line .* missing keyword.*")) {
                throw e;
            }
        }
    }

    static class Builder {
        final String moduleName;
        final Path sourceFile;
        final Set<String> modules = new HashSet<>();
        public Builder(String name) {
            this.moduleName = name;
            this.sourceFile = DIR.resolve(name).resolve("module-info.java");
        }

        public Builder modules(String... names) {
            Arrays.stream(names).forEach(modules::add);
            return this;
        }

        public Builder sourceFile(String... lines) throws IOException {
            Files.createDirectories(sourceFile.getParent());
            try (BufferedWriter bw = Files.newBufferedWriter(sourceFile);
                 PrintWriter writer = new PrintWriter(bw)) {
                writer.format("module %s {%n", moduleName);
                for (String l : lines) {
                    writer.println(l);
                }
                writer.println("}");
            }
            return this;
        }

        public GenModuleInfoSource build() throws IOException {
            return build(Collections.emptyList());
        }

        public GenModuleInfoSource build(Path extraFile) throws IOException {
            return build(Collections.singletonList(extraFile));
        }

        public GenModuleInfoSource build(List<Path> extraFiles) throws IOException {
            return new GenModuleInfoSource(sourceFile, extraFiles, modules);
        }
    }

}