package inport;

import java.io.*;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Supplier;

import static inport.Testing.*;

import inport.ConversionUtils.*;

import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;

public class Main {
    private static final int DEFAULT_TIME_LIMIT_S = 3600;

    private enum ConversionType {
        Undefined       ("", Testing::getTask_2_Solver),
        WithoutSplitting("Without splitting", Testing::getTask_2_Solver),
        WithSplitting   ("With splitting", Testing::getTaskWithPartialCargoOp_Solver),
        Greedy          ("Greedy", Testing::getTaskWithGreedyConstraints_Solver),
        Greedy_v2       ("Greedy v2", Testing::getTaskWithGreedyConstraintsV2_Solver);

        private final String text;
        private final Supplier<Solver> solversGetter;

        static final String legalValues = "\"Without splitting\", \"With splitting\", \"Greedy\", \"Greedy v2\"";

        ConversionType(String text, Supplier<Solver> solversGerrer) {
            this.text = text;
            this.solversGetter = solversGerrer;
        }
        public static ConversionType fromString(String text) {
            for (ConversionType t : ConversionType.values()) {
                if (t.text.equalsIgnoreCase(text)) {
                    return t;
                }
            }
            return Undefined;
        }
    }

    private static String undefinedTypeErrorMess(String undefType) {
        StringBuilder s = new StringBuilder("Undefined conversion type - \"" + undefType + "\".\n");
        ArrayList<String> values = new ArrayList<>();
        for (ConversionType conversionType : ConversionType.values()) {
            if (! conversionType.equals(ConversionType.Undefined)) {
                values.add("\"" + conversionType.text + "\"");
            }
        }
        s.append("Conversion type can be one of ").append(String.join(", ", values)).append(".");
        return s.toString();
    }

    private static class MainCommandsData {
        Boolean isHidden;
        String description;
        Consumer<Collection<String>> command;

        MainCommandsData(Boolean isHidden, String description, Consumer<Collection<String>> command) {
            this.isHidden = isHidden;
            this.description = description;
            this.command = command;
        }
    }

    private void solve(Collection<String> args) {
        try {
            class Arguments {
                @Option(name = "-fzs", aliases = "--flat_zinc_solver", usage = "Путь к исполняемому файлу flatZinc solver-а.", forbids = {"-s"})
                private String flatZincSolver = "";

                @Option(name = "-p", usage = "Путь к задаче.", required = true)
                private String pathToTask = "";

                @Option(name = "-ct", usage = "Тип сведения, один из " + ConversionType.legalValues + ".")
                private String conversionType = ConversionType.WithoutSplitting.text;

                @Option(name = "-s", aliases = "--solver", usage = "Тип solver-а из предопределённого списка : " + Solver.SolverName.legalValues + ".",
                        forbids = {"-fzs"})
                private String solverName = Solver.SolverName.Chuffed.text;
            }


            Arguments arguments = new Arguments();
            CmdLineParser parser = new CmdLineParser(arguments);

            if (args.isEmpty()) {
                parser.printUsage(System.out);
                return;
            }
            parser.parseArgument(args);

            long start = System.currentTimeMillis();

            TaskCase task = new TaskCase();
            task.deserialize(arguments.pathToTask);

            Solver solver;
            if (! task.isTypified()) {
                solver = getTask_2_Solver();
            } else {
                ConversionType t = ConversionType.fromString(arguments.conversionType);
                if (t.equals(ConversionType.Undefined)) {
                    System.out.println(undefinedTypeErrorMess(arguments.conversionType));
                    return;
                }
                solver = t.solversGetter.get();
            }

            solver.setTask(task);
            solver.setTimeLimitS(DEFAULT_TIME_LIMIT_S);
            solver.setTempDir("temp_data");

            if (arguments.flatZincSolver.isEmpty()) {
                solver.setSolverName(arguments.solverName);
            } else {
                solver.setFlatZincSolver(arguments.flatZincSolver);
            }

            String error = solver.solve();

            long finish = System.currentTimeMillis();
            System.out.println((finish - start) + " milliseconds");

            if (!error.isEmpty()) {
                System.out.println("Error : " + error);
            } else {
                task.serialize(arguments.pathToTask);
            }
        } catch (IOException ex) {
            throw new UncheckedIOException(ex);
        } catch (CmdLineException ex) {
            System.out.println("Illegal arguments: " + ex.getLocalizedMessage());
        }
    }

    private void doMain(final String[] args) throws IOException {
        final CmdLineParser parser = new CmdLineParser(this);

        Map<String, MainCommandsData> mainCommands = new TreeMap<>();

        Consumer<Boolean> c = (Boolean b) -> {};

        mainCommands.put("solve",
                new MainCommandsData(false, "Решение задачи.", this::solve));

        mainCommands.put("tippToMzn",
                new MainCommandsData(
                        false
                        , "Сводит задачу к формату MiniZinc-а используя заданное сведение. " +
                          "Производит два файла - conversion.mzn и minizinc_data.dzn ."
                        , (Collection<String> a) ->
                {
//                    try {
//                        // TODO реализовать
//                    } catch (IOException ex) {
//                        throw new UncheckedIOException(ex);
//                    }
                }));


        if (args.length < 1) {
            System.out.println("usage: java -jar Conversion.jar <command> [<args>]");
            System.out.println("Стандартные команды: ");

            int maxLength = 0;
            for (String name : mainCommands.keySet()) {
                if (! mainCommands.get(name).isHidden) {
                    maxLength = Math.max(maxLength, name.length());
                }
            }

            for (String name : mainCommands.keySet()) {
                MainCommandsData data = mainCommands.get(name);
                if (! data.isHidden) {
                    System.out.print(name);
                    for (int i = maxLength - name.length(); i > 0; i--) {
                        System.out.print(" ");
                    }
                    System.out.println("    " + data.description);
                }
            }
            return;
        }

        MainCommandsData data = mainCommands.get(args[0]);
        if (data == null) {
            System.out.println("Unknown type \"" + args[0] + "\"");
            return;
        }
        data.command.accept(Arrays.asList(args).subList(1, args.length));
/*
        String type = args[0];
        // TODO переделать
        switch (type) {
            case "solve" : {

                break;
            }
            case "to_MiniZinc_0" : {
                String input = args[1];
                String output = args[2];
                TaskCase task = new TaskCase();

                task.deserialize(input);
                Task.portToMiniZinc_0(task, output);
                break;
            }
            case "to_MiniZinc_1" : {
                String input = args[1];
                String output = args[2];
                TaskCase task = new TaskCase();
                task.deserialize(input);
                Task.portToMiniZinc_1(task, output);
                break;
            }
            case "resolve_result" : {
                String input = args[1];
                String fileWIthResult = args[2];
                String output = args[3];

                try {
                    TaskCase task = new TaskCase();
                    task.deserialize(input);

                    MZnResultsResolver.resolveMiniZincResults(task, fileWIthResult);

                    task.serialize(output);
                } catch (ParserException ex) {
                    System.out.println(ex.getMessage());
                }
                break;
            }
            case "debug" : {
                ConversionType t = (args.length == 1) ? ConversionType.WithoutSplitting
                        : ConversionType.fromString(args[1]);
                if (t.equals(ConversionType.Undefined)) {
                    System.out.println(undefinedTypeErrorMess(args[1]));
                    return;
                }
                Solver s = t.solversGetter.get();

                System.out.println(args[1] + " " + t.text + " " + s.getFlatZincSolver());

                s.setFlatZincSolver(flatZincSolver);
                debug(s, DEFAULT_TIME_LIMIT_S);
                break;
            }
            case "debug read-write" : {
                debugReadWrite();
                break;
            }
            case "testing" :
                ConversionType t = (args.length == 1) ? ConversionType.WithoutSplitting
                        : ConversionType.fromString(args[1]);
                if (t.equals(ConversionType.Undefined)) {
                    System.out.println(undefinedTypeErrorMess(args[1]));
                    return;
                }
                testGroup("with_typing", t.solversGetter.get(), DEFAULT_TIME_LIMIT_S);
                break;
            case "test_experiment":
                testGroup("experiments", getTask_2_Solver(), DEFAULT_TIME_LIMIT_S);
                break;
            case "different_parameters":
                testingWithDiffParameters(
                        "tests/with_typing/Case2.tipp",
                        1, 30,
                        16, 35,
                        1.1, 30);

//                    testingWithDiffParameters(
//                            "tests/with_typing/TaskT.tipp",
//                            10, 10,
//                            32, 32,
//                            1.1, 10);
                break;
            default:
                System.out.println("Unknown type \"" + type + "\"");
        }
        */
    }

    public static void main(String[] args) {
        final Main instance = new Main();
        try {
            instance.doMain(args);
        } catch (IOException ioEx) {
            System.out.println("ERROR: I/O Exception encountered: " + ioEx);
        }
    }

    private static void debug(Solver solver, int timeLimitS) {
        String fileName = "experiment/in.ipp";
        String solverResults = "experiment/solver_results.txt";
        String output = "experiment/debug_info.txt";

        TaskCase task = new TaskCase();
        try {
            task.deserialize(fileName);
        } catch (IOException e) {
            System.out.println(e.getMessage());
            return;
        }

        long start = System.currentTimeMillis();

        solver.setTimeLimitS(timeLimitS);
        solver.setTempDir("temp_data");
        solver.setTask(task);
        solver.setSolverResults(solverResults);
        String error = solver.solve();

        long finish = System.currentTimeMillis();
        System.out.println("    " + (finish - start) / 1000.0 + " s");

        if (!error.isEmpty()) {
            System.out.println("Error : " + error);
            return;
        } else {
            task.serialize(fileName);
        }

        debugInfo(task, solverResults, output);
    }

    private static void debugReadWrite() {
        String fileName = "experiment/in.ipp";

        TaskCase task = new TaskCase();
        try {
            task.deserialize(fileName);
        } catch (IOException e) {
            System.out.println(e.getMessage());
            return;
        }
        task.serialize(fileName);
    }

    private static void debugInfo(TaskCase task, String solverResults, String output) {
        try (FileInputStream fstream = new FileInputStream(solverResults)) {
            BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
            FileWriter writer = new FileWriter(output, false);

            {
                ArrayList<OperationTemplate> operations = new ArrayList<>(task.getTemplates());
                if (task.isTypified()) {
                    operations = Task.renumberOperations(task);
                }
                writer.write("operations :\n");
                int no = 1;
                for (OperationTemplate op : operations) {
                    writer.write("    " + no + " " + op.toString() + "\n");
                    no++;
                }
                writer.write("\n");
            }
            Task t = new Task(task, "");
            {
                ArrayList<MovingObject> movingObjects = Task.calcMovingObjects(task);

                Map<Integer, MovingObject> objByNo = new TreeMap<>();
                for (MovingObject obj : movingObjects) {
                    objByNo.put(t.getMObjNumberById().get(obj.getId()), obj);
                }

                writer.write("moving_objects : \n");
                for (int i = 0; i < movingObjects.size(); i++) {
                    writer.write("    " + (i + 1) + " " + objByNo.get(i).toString() + "\n");
                }
                writer.write("\n");
            }

            String line;

            while (((line = br.readLine()) != null)) {
                System.out.println("line : " + line);

                line = line.trim();
                if (line.equals("")) {
                    continue;
                }
                int pos = 0;
                while ((pos < line.length()) && (line.charAt(pos) != ' ')) {
                    pos++;
                }
                String name = line.substring(0, pos);

                if ((name.equals("----------")) || (name.equals("=====UNSATISFIABLE====="))) {
                    break;
                }

                System.out.println(name);

                ArrayList<ArrayList<String>> array = MZnResultsResolver.parse2dArray(pos, line, task);
                if (array != null) {
                    int maxSize = 0;

                    for (ArrayList<String> a : array) {
                        for (int j = 0; j < a.size(); j++) {
                            if (a.get(j).equals("true")) {
                                a.set(j, "1");
                            }
                            if (a.get(j).equals("false")) {
                                a.set(j, "0");
                            }
                            maxSize = Math.max(maxSize, a.get(j).length());
                        }
                    }
                    writer.write(name + " :\n");
                    for (ArrayList<String> a : array) {
                        writer.write("    ");
                        for (String val : a) {
                            writer.write(new String(new char[maxSize - val.length()]).replace("\0", " ")
                                         + val + " ");
                        }
                        writer.write("\n");
                    }
                    writer.write("\n");
                }
            }
            writer.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}