package inport;

import java.io.*;
import java.util.ArrayList;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Supplier;

import static inport.Testing.*;

import inport.ConversionUtils.MZnResultsResolver;
import inport.ConversionUtils.ParserException;
import inport.ConversionUtils.Solver;
import inport.ConversionUtils.Task;

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;

    @Option(name="-fzs", aliases="--flat_zinc_solver", usage="Path to executable file of flat zinc solver.")
    private String flatZincSolver = "";

    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;

        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 void doMain(final String[] args) throws IOException {
        final CmdLineParser parser = new CmdLineParser(this);
        if (args.length < 1) {
            parser.printUsage(System.out);
            System.exit(-1);
        }
        /* TODO
        try {
            parser.parseArgument(args);
        } catch (CmdLineException clEx) {
            System.out.println("ERROR: Unable to parse command-line options: " + clEx);
        }
*/
//        flatZincSolver = "external_tools/or-tools_flatzinc_Ubuntu-18.04-64bit_v7.2.6977/bin/fzn-or-tools";

        String type = args[0];

        switch (type) {
            case "solve" : {
                String fileName = args[1];
                long start = System.currentTimeMillis();

                TaskCase task = new TaskCase();
                task.deserialize(fileName);

                Solver solver;
                if (!task.isTypified()) {
                    solver = getTask_2_Solver();
                } else {
                    ConversionType t = (args.length == 2) ? ConversionType.WithoutSplitting
                            : ConversionType.fromString(args[2]);
                    if (t.equals(ConversionType.Undefined)) {
                        System.out.println(undefinedTypeErrorMess(args[2]));
                        return;
                    }
                    solver = t.solversGetter.get();
                }

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

                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(fileName);
                }
                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());
        }
    }
}