package inport;

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

import static inport.Testing.*;
import inport.ConversionUtil.*;

public class Main {

    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);
                } else {
                    error = solveTask_2(task);
                }

                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);
                    ConversionUtil.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);
                    ConversionUtil.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);

                    ConversionUtil.resolveMiniZincResults(task, fileWIthResult);

                    task.serialize(output);
                } catch (IOException | ParserException ex) {
                    System.out.println(ex.getMessage());
                }
                break;
            }
            case "debug" : {
                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());
                    break;
                }

                String error = solveTask_2(task);

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

                debugInfo(task, solverResults, output);

                break;
            }
            case "testing" :
                test_2();
                break;
            default:
                System.out.println("Unknown type \"" + type + "\"");
        }
    }

    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 = new ArrayList<>();
                movingObjects.addAll(task.getShips());
                movingObjects.addAll(task.getTows());
                movingObjects.addAll(task.getEquipments());

                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;

                if (line.charAt(pos) == '{') {
                    pos++;
                    int nextPos = pos;
                    while (line.charAt(nextPos) != '}') {
                        nextPos++;
                    }
                    arrayFirstDim = Integer.valueOf(line.substring(pos, nextPos).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());
                }

                if (name.equals("current_moving_operation")) {
                    ArrayList<ArrayList<Integer>> movingOpOfObj = t.getMovingOpOfObj();
                    for (int i = 0; i < elements.size(); i += arrayFirstDim) {
                        for (int j = 0; j < arrayFirstDim; j++) {
                            int val = Integer.valueOf(elements.get(i + j));
                            if (val != 0) {
                                elements.set(i + j, Integer.toString(movingOpOfObj.get(i / arrayFirstDim).get(val - 1)));
                            }
                        }
                    }
                    name = name + " *";
                }

                { // 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)) {
                    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");
                }
            }

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