package Blok_7_1;

import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.io.*;

public class Blok_7_1 {

    static Scanner scConsole;

    static final String YES = "1";
    static final String NO = "2";

    static String inputPathToFile() {
        boolean isIncorrect;
        String path;
        do {
            isIncorrect = false;
            path = scConsole.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                System.err.print("Файл не найден! Введите правильную ссылку: ");
                isIncorrect = true;
            }

        } while (isIncorrect);
        return path;
    }

    static boolean isCorrect(ArrayList<ArrayList<Integer>> m) {
        boolean isCorrect = true;
        for (int j = 0; j < m.size() && isCorrect; j++) {
            isCorrect = m.get(j).size() == m.get(0).size();
        }
        if (isCorrect) {
            int count = 0;
            for (int i = 0; i < m.get(0).size() && isCorrect; i++) {
                for (int j = 0; j < m.size(); j++) {
                    count += m.get(j).get(i);
                }
                isCorrect = count == 2;
                count = 0;
            }
        }

        return isCorrect;
    }

    static void readMatrixFromFile(ArrayList<ArrayList<Integer>> matrix) throws FileNotFoundException, IOException {
        System.out.print("\nВведите ссылку на файл с матрицей: ");
        String path = inputPathToFile();
        boolean toExit;
        boolean wrongFormat = false;
        String lineStr = "";
        BufferedReader scFile = new BufferedReader(new FileReader(new File(path)));
        do {
            toExit = false;
            lineStr = scFile.readLine();
            ArrayList<Integer> line = new ArrayList<>();
            if (lineStr != null) {
                lineStr = lineStr.trim();
                if (lineStr.matches("^((1|0) )+(1|0)$")) {
                    for (String str : lineStr.split(" ")) {
                        line.add(Integer.parseInt(str));
                    }
                    matrix.add(line);
                } else {
                    toExit = true;
                    scFile.close();
                    wrongFormat = true;
                }
            } else {
                toExit = true;
                scFile.close();
            }
            if (toExit) {
                if (wrongFormat || !isCorrect(matrix)) {
                    System.err.print("Данные в файле некорректы. Введите ссылку на другой файл: ");
                    path = inputPathToFile();
                    scFile = new BufferedReader(new FileReader(new File(path)));
                    toExit = false;
                    wrongFormat = false;
                    matrix.clear();
                }
            }
        } while (!toExit);
    }

    static String matrixToString(ArrayList<ArrayList<Integer>> matrix) {
        String str = "";
        for (ArrayList<Integer> line : matrix) {
            for (int i : line) {
                str += i + " ";
            }
            str += "\n";
        }
        return str;
    }

    static String listToString(ArrayList<ArrayList<Integer>> lists) {
        String str = "";
        int counter = 0;
        for (ArrayList<Integer> list : lists) {
            str += "\t" + (lists.indexOf(list) + 1) + ": ";
            counter = 0;
            for (int i : list) {
                if (counter != list.size() - 1) {
                    str += i + "-> ";
                    counter++;
                } else {
                    str += i;
                }
            }
            str += "\n";
        }
        return str;
    }

    static void getIncidenceLists(ArrayList<ArrayList<Integer>> matrix, ArrayList<ArrayList<Integer>> lists) {
        for (int i = 0; i < matrix.size(); i++) {
            ArrayList<Integer> incidenceList = new ArrayList<>();
            lists.add(incidenceList);
        }
        int firstNode = 0;
        int secondNode = 0;
        for (int i = 0; i < matrix.get(0).size(); i++) {
            firstNode = 0;
            secondNode = 0;
            for (int j = 0; j < matrix.size(); j++) {
                if (firstNode == 0 && matrix.get(j).get(i) == 1) {
                    firstNode = j + 1;
                } else if (secondNode == 0 && matrix.get(j).get(i) == 1) {
                    secondNode = j + 1;
                }
            }
            if (secondNode != 0) {
                lists.get(firstNode - 1).add(secondNode);
                lists.get(secondNode - 1).add(firstNode);
            }
        }
        for (ArrayList<Integer> list : lists) {
            list.sort(Integer::compareTo);
        }
    }

    static String getUserAnswer() {
        String answer = "";
        boolean isIncorrect;
        do {
            isIncorrect = false;
            answer = scConsole.nextLine();
            if (!(answer.equals(YES) || answer.equals(NO))) {
                isIncorrect = true;
                System.err.print("Некорректный ввод! Повторите попытку: ");
            }
        } while (isIncorrect);
        return answer;
    }

    static String userAnswer() {
        return getUserAnswer();
    }

    static void saveInFile(ArrayList<ArrayList<Integer>> matrix, ArrayList<ArrayList<Integer>> lists, String path) throws IOException {
        boolean isIncorrect;
        PrintWriter writer;
        do {
            isIncorrect = false;
            try {
                writer = new PrintWriter(path);
                writer.write("Исходная матрица инцидентности:\n");
                writer.write(matrixToString(matrix));
                writer.write("\nСписки инцидентности:\n");
                writer.write(listToString(lists));
                writer.close();
            } catch (Exception e) {
                System.err.print("Доступ к файлу закрыт! Ведите ссылк уна другой файл: ");
                isIncorrect = true;
                path = inputPathToFile();
            }
        } while (isIncorrect);
    }

    static void saveResult(ArrayList<ArrayList<Integer>> matrix, ArrayList<ArrayList<Integer>> lists) throws IOException {
        System.out.println("\nЖелаете сохранить результат в файл: \n1. Да; \n2. Нет (программа будет закрыта);");
        System.out.print("Сделайте выбор: ");
        switch (userAnswer()) {
            case YES:
                System.out.print("Введите ссылку на файл для вывода: ");
                String path = inputPathToFile();
                saveInFile(matrix, lists, path);
                System.out.println("Данные упешно сохранены!");
                break;

            case NO:
                return;
        }
    }

    public static void main(String[] args) throws FileNotFoundException, IOException {
        scConsole = new Scanner(System.in);
        System.out.println("Программа преобразует матрицу инцидентности в списки инцидентности.");
        ArrayList<ArrayList<Integer>> incidenceMatrix = new ArrayList<>();
        ArrayList<ArrayList<Integer>> incidenceList = new ArrayList<>();
        readMatrixFromFile(incidenceMatrix);
        System.out.println("\nИсходная матрица инцидентности: ");
        System.out.println(matrixToString(incidenceMatrix));
        getIncidenceLists(incidenceMatrix, incidenceList);
        System.out.println("\nСписки инцидентности: ");
        System.out.println(listToString(incidenceList));
        saveResult(incidenceMatrix, incidenceList);
        scConsole.close();
    }
}