import java.util.Scanner;
import java.io.*;
public class Main {

    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {
        writeTask();
        solution();
        scan.close();
    }

    public static void writeTask() {
        System.out.println("Данная программа находит седловую точку квадратной матрицы");
    }

    public static String fileInputPath(boolean isFileForRead){
        boolean isNotCorrect;
        String path;
        if (isFileForRead) {
            System.out.println("Введите путь к файлу для чтения: ");
        } else {
            System.out.println("Введите путь к файлу для записи: ");
        }
        do {
            isNotCorrect = false;
            path = scan.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                isNotCorrect = true;
                System.out.println("Файл не найден. Повторите попытку...");
            }
        } while (isNotCorrect);
        return path;
    }

    public static int fileInputMatrixOrder(String path) {
        final int MAX_ORDER = 10;
        final int MIN_ORDER = 2;
        boolean isFileForRead = true;
        boolean isNotCorrect;
        int order = 0;
        do {
            isNotCorrect = false;
            try(Scanner fileReader = new Scanner (new File (path))) {
                try {
                    order = Integer.parseInt(fileReader.next());
                } catch (NumberFormatException e) {
                    System.out.print("Некорректно введённый порядок матрицы. ");
                    isNotCorrect = true;
                }
                if ((!isNotCorrect) && ((order < MIN_ORDER) || (order > MAX_ORDER))) {
                    System.out.print("Порядок матрицы неверного диапазона! ");
                    isNotCorrect = true;
                }
            } catch (IOException e) {
                isNotCorrect = true;
                System.out.print("Не удалось открыть файл. ");
            }
            if (isNotCorrect)  {
                System.out.println("Повторите попытку...");
                path = fileInputPath(isFileForRead);
            }
        } while (isNotCorrect);
        return order;
    }

    public static int[][] fileMatrixInput(String path, int order) {
        boolean isNotCorrect;
        boolean isFileForRead = true;
        int[][] matrix = new int[order][order];
        int i = 0;
        int j;
        do {
            isNotCorrect = false;
            try(Scanner fileReader = new Scanner (new File (path))) {
                fileReader.nextLine();
                while ((!isNotCorrect) && (i < order)) {
                    j = 0;
                    while ((!isNotCorrect) && (j < order)) {
                        try {
                            matrix[i][j] = Integer.parseInt(fileReader.next());
                        } catch (NumberFormatException e) {
                            System.out.print("Ошибка! Найдено некорректное значение элемента матрицы. ");
                            isNotCorrect = true;
                            i--;
                        }
                        j++;
                    }
                    i++;
                }
            } catch (IOException e) {
                isNotCorrect = true;
                System.out.print("Не удалось открыть файл. ");
            }
            if (isNotCorrect) {
                System.out.println("Повторите попытку...");
                path = fileInputPath(isFileForRead);
            }
        } while (isNotCorrect);
        return matrix;
    }

    public static int consoleInputMatrixOrder() {
        final int MAX_ORDER = 10;
        final int MIN_ORDER = 2;
        boolean isNotCorrect;
        int order = 0;
        do {
            System.out.println("Введите порядок квадратной матрицы");
            isNotCorrect = false;
            try {
                order = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Ошибка ввода! Повторите попытку...");
                isNotCorrect = true;
            }
            if ((!isNotCorrect) && ((order < MIN_ORDER) || (order > MAX_ORDER))) {
                System.out.println("Ошибка ввода! Проверьте, входит ли ваше\nзначение порядка в диапазон, и повторите попытку");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return order;
    }

    public static int[][] consoleMatrixCreation(int order) {
        final int MAX_ELEMENT = 2147483647;
        final int MIN_ELEMENT = -2147483648;
        boolean isNotCorrect;
        int[][] matrix = new int[order][order];
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                do {
                    System.out.println("Введите " + (j + 1) + " элемент " + (i + 1) + " строки");
                    isNotCorrect = false;
                    try {
                        matrix[i][j] = Integer.parseInt(scan.nextLine());
                    } catch (NumberFormatException e) {
                        System.out.println("Ошибка ввода! Повторите попытку...");
                        isNotCorrect = true;
                    }
                    if ((!isNotCorrect) && ((matrix[i][j] < MIN_ELEMENT) || (matrix[i][j] > MAX_ELEMENT))) {
                        System.out.println("Ошибка ввода! Введено число неверного диапазона!");
                        isNotCorrect = true;
                    }
                } while (isNotCorrect);
            }
        }
        return matrix;
    }


    public static void consoleMatrixOutput(int[][] matrix) {
        System.out.println("Исходная матрица:");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static int[] smallestElementsInLine(int[][] matrix, int order) {
        int[] minIndexes = new int[order];
        int min;
        for (int i = 0; i < order; i++) {
            min = matrix[i][0];
            minIndexes[i] = 0;
            for (int j = 1; j < order; j++) {
                if (matrix[i][j] <= min) {
                    min = matrix[i][j];
                    minIndexes[i] = j;
                }
            }
        }
        return minIndexes;
    }

    public static int[] largestElementsInColumn(int[][] matrix, int order) {
        int[] maxIndexes = new int[order];
        int max;
        for (int j = 0; j < order; j++) {
            max = matrix[0][j];
            maxIndexes[j] = 0;
            for (int i = 0; i < order; i++) {
                if (matrix[i][j] >= max) {
                    max = matrix[i][j];
                    maxIndexes[j] = i;
                }
            }
        }
        return maxIndexes;
    }

    public static void findingMatrixSaddlePoints(int[][] matrix, boolean isConsoleAnswer) {
        int saddlePoint = 0;
        int order = matrix.length;
        int[] minElemIndexes = smallestElementsInLine(matrix, order);
        int[] maxElemIndexes = largestElementsInColumn(matrix, order);
        boolean isNotCorrect;
        boolean isSaddlePoint = false;
        String path;
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                if ((minElemIndexes[i] == j) && (maxElemIndexes[j] == i)) {
                    saddlePoint = matrix[i][j];
                    isSaddlePoint = true;
                }
            }
        }
        if (isConsoleAnswer) {
            if (isSaddlePoint) {
                System.out.println("Седловая точка матрицы: " + saddlePoint);
            } else {
                System.out.println("Седловой точки нет");
            }
        } else {
            boolean isFileForRead = false;
            do {
                isNotCorrect = false;
                path = fileInputPath(isFileForRead);
                try (FileWriter fileWriter = new FileWriter(new File(path))) {
                     if (isSaddlePoint) {
                             fileWriter.write("Седловая точка матрицы: " + saddlePoint);
                     } else {
                         fileWriter.write("Седловой точки нет");
                     }
                } catch (IOException e) {
                    System.out.println("Не удалось открыть файл. Повторите попытку...");
                    isNotCorrect = true;
                }
            } while (isNotCorrect);
            System.out.println("Седловая точка записана в файл");
        }
    }

    public static int[][] fileChoice() {
        boolean isFileForRead = true;
        String path = fileInputPath(isFileForRead);
        int order = fileInputMatrixOrder(path);
        int[][] matrix = fileMatrixInput(path, order);
        return matrix;
    }

    public static int[][] consoleChoice() {
        int order = consoleInputMatrixOrder();
        int[][] matrix = consoleMatrixCreation(order);
        consoleMatrixOutput(matrix);
        return matrix;
    }

    public static int chooseOutputMethod() {
        boolean isNotCorrect;
        int choice = 0;
        do {
            isNotCorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Число введено некорректно. Повторите попытку...");
                isNotCorrect = true;
            }
            if ((!isNotCorrect) && (choice != 1) && (choice != 2)) {
                System.out.println("Введите либо 1, либо 2. Ваш выбор: ");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return choice;
    }

    public static void solution() {
        boolean isConsoleAnswer = false;
        System.out.println("Введите число, чтобы выбрать способ решения задания:\n1 - через консоль, 2 - с помощью файлов");
        int choice = chooseOutputMethod();
        if (choice == 1) {
            isConsoleAnswer = true;
            int[][] matrix = consoleChoice();
            findingMatrixSaddlePoints(matrix, isConsoleAnswer);
        } else {
            int[][] matrix = fileChoice();
            System.out.println("Введите число, чтобы выбрать способ вывода решения задания:\n1 - через консоль, 2 - с помощью файлов");
            choice = chooseOutputMethod();
            if (choice == 1) {
                isConsoleAnswer = true;
                findingMatrixSaddlePoints(matrix, isConsoleAnswer);
            } else {
                findingMatrixSaddlePoints(matrix, isConsoleAnswer);
            }
        }
    }
}