package inport;

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

import static inport.Testing.*;

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

public class Main {

    private static final int DEFAULT_TIME_LIMIT_S = 3600;

    private enum ConversionType {
        Undefined              (""),
        WithoutSplitting("Without splitting"),
        WithSplitting   ("With splitting");

        private final String text;
        ConversionType(String text) {
            this.text = text;
        }
        public static ConversionType fromString(String text) {
            for (ConversionType t : ConversionType.values()) {
                if (t.text.equalsIgnoreCase(text)) {
                    return t;
                }
            }
            return Undefined;
        }
    }

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("To few arguments.");
            return;
        }
        String type = args[0];

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

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

                String error;
                if (!task.isTypified()) {
                    error = solveTask_1(task, DEFAULT_TIME_LIMIT_S);
                } else {
                    ConversionType t = (args.length == 2) ? ConversionType.WithoutSplitting
                                                          : ConversionType.fromString(args[2]);

                    String constraintName;

                    switch (t) {
                        case WithSplitting:
                            constraintName = "conversion_2_with_partial_cargo_operations.mzn";
                            break;
                        case WithoutSplitting:
                            constraintName = "conversion_2.mzn";
                            break;
                        default:
                            System.out.println("Undefined conversion type - \"" + args[2] + "\".");

                            ArrayList<String> values = new ArrayList<>();
                            for (ConversionType conversionType : ConversionType.values()) {
                                if (! conversionType.equals(ConversionType.Undefined)) {
                                    values.add("\"" + conversionType.text + "\"");
                                }
                            }
                            System.out.print("Conversion type can be one of " + String.join(", ", values) + ".");
                            return;
                    }

                    error = solveTask(
                            task,
                            constraintName,
                            Task::portToMiniZinc_2,
                            MZnResultsResolver::resolveMiniZincResults,
                            DEFAULT_TIME_LIMIT_S);
                }

                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();
                try {
                    task.deserialize(input);
                    Task.portToMiniZinc_0(task, output);
                } catch (IOException ex) {
                    System.out.println(ex.getMessage());
                }
                break;
            }
            case "to_MiniZinc_1" : {
                String input = args[1];
                String output = args[2];
                TaskCase task = new TaskCase();
                try {
                    task.deserialize(input);
                    Task.portToMiniZinc_1(task, output);
                } catch (IOException ex) {
                    System.out.println(ex.getMessage());
                }
                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 (IOException | ParserException ex) {
                    System.out.println(ex.getMessage());
                }
                break;
            }
            case "debug" : {
                debug(Testing::solveTask_2, DEFAULT_TIME_LIMIT_S);
                break;
            }
            case "debug 2" : {
                debug(Testing::solveTaskWithPartialCargoOp, DEFAULT_TIME_LIMIT_S);
                break;
            }
            case "debug greedy" : {
                debug(Testing::solveTaskWithGreedyConstraints, DEFAULT_TIME_LIMIT_S);
                break;
            }
            case "debug greedy v2" : {
                debug(Testing::solveTaskWithGreedyConstraintsV2, DEFAULT_TIME_LIMIT_S);
                break;
            }
            case "debug read-write" : {
                debugReadWrite();
                break;
            }
            case "testing" :
                test_2(DEFAULT_TIME_LIMIT_S);
                break;
            case "test_experiment":
                testGroup("experiments", Testing::solveTask_2, DEFAULT_TIME_LIMIT_S);
                break;
            case "testing_with_partial_op":
                testWithPartialOp(DEFAULT_TIME_LIMIT_S);
                break;
            case "different_parameters":
                try {
                    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);

                } catch (IOException ex) {
                    System.out.println(ex.getMessage());
                }
                break;
            default:
                System.out.println("Unknown type \"" + type + "\"");
        }
    }

    private static void debug(BiFunction<TaskCase, Integer, String> solver, int timeLimitS) {
        String fileName = "experiment/in.ipp";
        String solverResults = "temp_data/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();

        String error = solver.apply(task, timeLimitS);

        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;
            int linesNumber = 0;

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

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

                while ((pos < line.length()) && (line.charAt(pos) != '[') && (line.charAt(pos) != '{')) {
                    pos++;
                }

                int arrayFirstDim = ((int) task.getPlanningInterval()) + 2;
                int arraySecondDim = 0;

                if (line.charAt(pos) == '{') {
                    pos++;
                    int nextPos = pos;
                    while (line.charAt(nextPos) != '}') {
                        nextPos++;
                    }
                    String []dimensions = line.substring(pos, nextPos).trim().split(" ");
                    if (dimensions.length > 0) {
                        arrayFirstDim = Integer.valueOf(dimensions[0].trim());
                    }
                    if (dimensions.length > 1) {
                        arraySecondDim = Integer.valueOf(dimensions[1].trim());
                    }

                    pos = nextPos + 1;
                    while (line.charAt(pos) != '[') {
                        pos++;
                    }
                }

                int pos2 = pos;
                while ((pos2 < line.length()) && (line.charAt(pos2) != ']')) {
                    pos2++;
                }
                String values = line.substring(pos + 1, pos2);
                ArrayList<String> elements = new ArrayList<>();

                for (String val : values.split(",")) {
                    elements.add(val.trim());
                }

                { // bool to int
                    for (int i = 0; i < elements.size(); i++) {
                        if (elements.get(i).equals("true")) {
                            elements.set(i, "1");
                        }
                        if (elements.get(i).equals("false")) {
                            elements.set(i, "0");
                        }
                    }
                }

                int maxLength = 0;
                for (String val : elements) {
                    maxLength = Math.max(maxLength, val.length());
                }

                if ((arrayFirstDim != 0) && (elements.size() % arrayFirstDim == 0) && ((arraySecondDim == 0) || (elements.size() % (arrayFirstDim * arraySecondDim) != 0))) {
                    writer.write(name + " :\n");
                    for (int i = 0; i < elements.size(); i += arrayFirstDim) {
                        writer.write("    ");
                        for (int j = 0; j < arrayFirstDim; j++) {
                            String val = elements.get(i + j);
                            for (int k = val.length(); k < maxLength; k++) {
                                writer.write(" ");
                            }
                            writer.write(val + " ");
                        }
                        writer.write("\n");
                    }
                    writer.write("\n");
                } else if ((arrayFirstDim != 0) && (arraySecondDim != 0) && (elements.size() % (arrayFirstDim * arraySecondDim) == 0)) {
                    writer.write(name + " :\n");
                    for (int i = 0; i < elements.size(); i += arrayFirstDim * arraySecondDim) {
                        for (int j = 0; j < arrayFirstDim; j++) {
                            writer.write("    ");
                            for (int k = 0; k < arraySecondDim; k++) {
                                String val = elements.get(i + j * arraySecondDim + k);
                                for (int l = val.length(); l < maxLength; l++) {
                                    writer.write(" ");
                                }
                                writer.write(val + " ");
                            }
                            writer.write("\n");
                        }
                        writer.write("\n");
                    }
                    writer.write("\n");
                }
            }

            writer.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}