package inport;

import java.io.*;
import java.util.ArrayList;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Testing {
    private static void removeDirectory(File dir) {
        if (dir.isDirectory()) {
            File[] files = dir.listFiles();
            if (files != null && files.length > 0) {
                for (File aFile : files) {
                    removeDirectory(aFile);
                }
            }
        }
        dir.delete();
    }

    public static String solveTask_1(TaskCase task) {
        return solveTask(
                task,
                "conversion_1.mzn",
                ConversionUtil::portToMiniZinc_1,
                ConversionUtil::resolveMiniZincResults);
    }

    public static String solveTask_2(TaskCase task) {
        return solveTask(
                task,
                "conversion_2.mzn",
                ConversionUtil::portToMiniZinc_2,
                ConversionUtil::resolveMiniZincResults);
    }

    public static String solveTask_2_0(TaskCase task) {
        return solveTask(
                task,
                "conversion_2.0.mzn",
                ConversionUtil::portToMiniZinc_2,
                ConversionUtil::resolveMiniZincResults,
                "temp_data_2");
    }

    public static String solveTask(TaskCase task,
                                   String constraintName,
                                   BiConsumer<TaskCase, String> converterToMinizincFormat,
                                   BiConsumer<TaskCase, String> interpreter) {
        return solveTask(task, constraintName, converterToMinizincFormat, interpreter, "temp_data");
    }

    /* Возвращает описание ошибки, если ошибки не было, то пустую строку. */
    public static String solveTask(TaskCase task,
                                   String constraintName,
                                   BiConsumer<TaskCase, String> converterToMinizincFormat,
                                   BiConsumer<TaskCase, String> interpreter,
                                   String tempDir) {
        File directory = new File(tempDir);
        if (!directory.exists()) {
            directory.mkdir();
        }

        tempDir = tempDir + "/";
        String minizincData = tempDir + "minizinc_data.dzn";
        String solverResults = tempDir + "solver_results.txt";
        String constraints = tempDir + "constraints.mzn";

        try {
            try (FileWriter res = new FileWriter(constraints)) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(Main.class.getResourceAsStream("/constraints/" + constraintName)));
                String line;
                while ((line = reader.readLine()) != null) {
                    res.write(line + "\n");
                }
            }
            converterToMinizincFormat.accept(task, minizincData);

            ProcessBuilder pb = new ProcessBuilder("minizinc",
                    "--solver", "Chuffed",
                    constraints, minizincData,
                    "-o", solverResults);

            Process process = pb.start();
            int exitCode = process.waitFor();
            assert exitCode == 0;

            BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String output = br.lines().collect(Collectors.joining("\n"));

//            BufferedReader br2 = new BufferedReader(new InputStreamReader(process.getErrorStream()));
//            String errors = br.lines().collect(Collectors.joining("\n"));


//            System.out.println("output : " + output);
//            System.out.println("errors : " + errors);

            if (output.trim().equals("=====UNSATISFIABLE=====")) {
                task.setSolution(new ArrayList<>());
                task.setSolution_result(-1);
            } else {
                interpreter.accept(task, solverResults);
            }
        } catch (UncheckedIOException | IOException | InterruptedException | ParserException ex) {
            return ex.getMessage();
        } finally {
//            removeDirectory(directory);
        }
        return "";
    }

    private static String testCase(String file, Function<TaskCase, String> solver) {
        TaskCase task = new TaskCase();
        try {
            task.deserialize(file);
        } catch (IOException e) {
            return "Error : " + e.getMessage();
        }
        double expected_result = task.getSolution_result();
        String error = solver.apply(task);
        double result = task.getSolution_result();
        if (!error.isEmpty()) {
            return "Error : " + error;
        }
        if (expected_result != result) {
            return "WA : expected " + expected_result + ", found " + result;
        }
        return "OK";
    }

    public static void testGroup(String group, Function<TaskCase, String> solver) {
        File testDir = new File("tests/" + group + "/");
        System.out.println(testDir.toString() + " :");

        int nPassedTests = 0;

        for (File file : testDir.listFiles()) {
            System.out.println("  " + file.getName() + " : ");

            long start = System.currentTimeMillis();

            String res = testCase(testDir.toString() + "/" + file.getName(), solver);

            long finish = System.currentTimeMillis();
            System.out.println("    " + res + ", " + (finish - start) + " ms");
            if (res.equals("OK")) {
                nPassedTests++;
            }
        }
        System.out.println("Passed tests : " + nPassedTests + "/" + testDir.listFiles().length);
    }

    public static void test_1() {
        testGroup("without_typing", Testing::solveTask_1);
    }

    public static void test_2() {
        testGroup("with_typing", Testing::solveTask_2);
    }
    public static void test_2_0() {
        testGroup("with_typing", Testing::solveTask_2_0);
    }
    public static void test_2_exp() {
        testGroup("experiments", Testing::solveTask_2);
    }
}