Laba.4.2(Java)

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

public class Main {
    private static final int MIN_SIZE = 2;
    private static final int MAX_SIZE = 10;
    private static final int MIN_VALUE = 0;
    private static final int MAX_VALUE = 1;
    private static final Scanner scan = new Scanner(System.in);
    private static int counter = 0;
    public static void outputTaskInfo() {
        System.out.println("Данная программа находит максимальную площадь подматриц, состоящей из единиц, полученную из данной матрицы" + "\n" +
                "Диапазон ввода значений длины и ширины: " + MIN_SIZE + "..." + MAX_SIZE + ". \n" +
                "Диапазон ввода значений в матрицу: " + MIN_VALUE + "..." + MAX_VALUE + ".");
    }

    public static int getVerificationOfChoice() {
        int choice = 0;
        boolean isIncorrect;

        do {
            isIncorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Проверьте корректность ввода данных!");
                isIncorrect = true;
            }
            if (!isIncorrect && (choice != 0 && choice != 1)) {
                System.out.println("Для выбора введите 0 или 1!");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return choice;
    }

    public static String inputPathToFile() {
        boolean isIncorrect;
        String path;

        System.out.println("Укажите путь к файлу: ");

        do {
            isIncorrect = false;
            path = scan.nextLine();
            File file = new File(path);

            if (!file.exists()) {
                System.out.println("По указанному пути файл не найден! Укажите правильный путь: ");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return path;
    }

    public static int readLengthFromConsole() {
        int length = 0;
        boolean isIncorrect;

        System.out.println("Введите значение длины матрицы: ");

        do {
            isIncorrect = false;
            try {
                length = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Проверьте корректность ввода данных!");
                isIncorrect = true;
            }
            if (!isIncorrect && (length < MIN_SIZE || length > MAX_SIZE)) {
                System.out.println("Введите число от " + MIN_SIZE + " до " + MAX_SIZE + "! \n");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return length;
    }

    public static int readLengthFromFile(final String path) {
        int length;
        boolean isIncorrect = true;

        System.out.println("Происходит чтение длины матрицы...");

        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            length = Integer.parseInt(br.readLine());
        } catch (Exception e) {
            isIncorrect = false;
            System.out.println("Ошибка при чтении данных! Введите количество уравнений с консоли!");
            length = readLengthFromConsole();
        }

        return length;
    }

    public static void outputLength(final int choice, int length, String path) {
        boolean isIncorrect;

        if (choice == 0)
            System.out.println("Длина матрицы равна: " + length + ".");

        if (choice == 1) {
            System.out.println("Вывод длины матрицы в файл...");

            do {
                isIncorrect = false;
                try {
                    FileWriter writer = new FileWriter(path);
                    writer.write(length + "\n");
                    writer.close();
                } catch (IOException e) {
                    isIncorrect = true;
                    System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                    path = inputPathToFile();
                }
            } while (isIncorrect);

            System.out.println("Данные успешно записаны в файл!");
        }
    }

    public static int readWidthFromConsole() {
        int width = 0;
        boolean isIncorrect;

        System.out.println("Введите значение ширины матрицы: ");

        do {
            isIncorrect = false;
            try {
                width = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Проверьте корректность ввода данных!");
                isIncorrect = true;
            }
            if (!isIncorrect && (width < MIN_SIZE || width > MAX_SIZE)) {
                System.out.println("Введите число от " + MIN_SIZE + " до " + MAX_SIZE + "! \n");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return width;
    }

    public static int readWidthFromFile(final String path) {
        int width;
        boolean isIncorrect = true;

        System.out.println("Происходит чтение ширины матрицы...");

        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            br.readLine();
            width = Integer.parseInt(br.readLine());
        } catch (Exception e) {
            isIncorrect = false;
            System.out.println("Ошибка при чтении данных! Введите количество уравнений с консоли!");
            width = readLengthFromConsole();
        }

        return width;
    }

    public static void outputWidth(final int choice, int width, String path) {
        boolean isIncorrect;

        if (choice == 0)
            System.out.println("Ширина матрицы равна: " + width + ".");

        if (choice == 1) {
            System.out.println("Вывод длины матрицы в файл...");

            do {
                isIncorrect = false;
                try {
                    FileWriter writer = new FileWriter(path);
                    writer.write(width + "\n");
                    writer.close();
                } catch (IOException e) {
                    isIncorrect = true;
                    System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                    path = inputPathToFile();
                }
            } while (isIncorrect);

            System.out.println("Данные успешно записаны в файл!");
        }
    }

    public static int[][] fillMatrixFromConsole(final int length, final int width) {
        int[][] matrix = new int[length][width];
        boolean isIncorrect;

        for (int i = 0; i < length; i++) {
            for (int j = 0; j < width; j++) {
                System.out.println("Введите значение матрицы в " + (i + 1) + "-ой строке " + (j + 1) + "-ого столбца: ");

                do {
                    isIncorrect = false;
                    try {
                        matrix[i][j] = Integer.parseInt(scan.nextLine());
                    } catch (NumberFormatException e) {
                        System.out.println("Проверьте корректность ввода данных!");
                        isIncorrect = true;
                    }

                    if (!isIncorrect && (matrix[i][j] < MIN_VALUE || matrix[i][j] > MAX_VALUE)) {
                        isIncorrect = true;
                        System.out.println("Введите число от " + MIN_VALUE + " до " + MAX_VALUE + "!");
                    }
                } while (isIncorrect);
            }
        }

        return matrix;
    }

    public static int[][] fillMatrixFromFile (final int length, final int width, final String path) throws FileNotFoundException {
        int[][] matrix = new int[length][width];
        int count = 0 ;
        Scanner fr = new Scanner(new File(path));

        System.out.println("Чтение матрицы...");
        fr.nextLine();
        fr.nextLine();
        while (fr.hasNext()) {
            fr.next();
            count++;
        }

        fr.close();

        if (count > length * width) {
            System.out.println("Ошибка при чтении матрицы! Введите матрицу с консоли!");
            matrix = fillMatrixFromConsole(length, width);
        } else {
            fr = new Scanner(new File(path));
            fr.nextLine();
            fr.nextLine();

            for (int i = 0; i < length; i++) {
                for (int j = 0; j < width; j++) {
                    try {
                        matrix[i][j] = fr.nextInt();
                    } catch (Exception e) {
                        System.out.println("Ошибка при считывании матрицы из файла!Введите матрицу с консоли!");
                        matrix = fillMatrixFromConsole(length, width);
                    }
                    if (matrix[i][j] < MIN_VALUE || matrix[i][j] > MAX_VALUE) {
                        System.out.println("Ошибка при считывании матрицы из файла!Введите матрицу с консоли!");
                        matrix = fillMatrixFromConsole(length, width);
                    }
                }
            }
        }

        return matrix;
    }
    public static void outputMatrix(final int choice, String path, final int[][] matrix, final int length, final int width) {
        boolean isIncorrect;

        if (choice == 0) {
            System.out.println("Вывод начальной матрицы: ");
            for (int i = 0; i < length; i++)
            {
                for (int j = 0; j < width; j++)
                    System.out.print(matrix[i][j] + "\t");
                System.out.print("\n");
            }
            System.out.print("\n");
        }

        if (choice == 1) {
            System.out.println("Вывод начальной матрицы в файл...");

            do {
                isIncorrect = false;
                try {
                    FileWriter writer = new FileWriter(path, true);
                    BufferedWriter bufferWriter = new BufferedWriter(writer);

                    for (int i = 0; i < length; i++)
                    {
                        for (int j = 0; j < width; j++)
                            bufferWriter.write(matrix[i][j] + "\t");
                        bufferWriter.write("\n");
                    }
                    bufferWriter.write("\n");

                    bufferWriter.close();
                    writer.close();
                } catch (IOException e) {
                    isIncorrect = true;
                    System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                    path = inputPathToFile();
                }
            } while (isIncorrect);

            System.out.println("Данные успешно записаны в файл!");
        }
    }

    public static void changePos(final int[][] matrix, int row, int col) {
        col++;
        if (col > matrix.length - 1)
        {
            col %= matrix.length;
            row++;
        }
    }

    public static int getSumInRow(int[][] matrix, int row, int col) {
        int newRow, newCol, sum, temp;
        newRow = row;
        newCol = col;
        temp = matrix.length;
        sum = 0;
        while (newRow < matrix.length && matrix[newRow][col] == 1) {
            newCol = col;
            while (newCol < matrix[0].length && matrix[newRow][newCol] == 1) {
                newCol++;
            }

            if (temp > (newCol - col))
                temp = newCol - col;

            newRow++;
            sum = (newRow - row) * temp;

            if (sum > counter)
                counter = sum;
        }
        return counter;
    }

    public static int findArea(int[][] matrix, int row, int col) {
        int sumRow, count;
        sumRow = 0;
        count = 0;
        do {
            if (row == matrix.length - 1 && col == matrix[0].length - 1) {
                count = matrix[matrix.length - 1][matrix[0].length - 1];
                return count;
            } else {
                if (matrix[row][col] == 0) {
                    changePos(matrix, row, col);
                    sumRow = findArea(matrix, row, col);
                } else {
                    sumRow = getSumInRow(matrix, row, col);
                    changePos(matrix, row, col);
                }
            }

            if (sumRow > count) {
                count = sumRow;
            }
        } while (row == matrix.length - 1 && col == matrix[0].length - 1);

        return count;
    }

    public static void outputArea(final int choice, String path, final int area) {
        boolean isIncorrect;

        if (choice == 0)
            System.out.println("Площадь полученной подматрицы равна " + area + ".");
        if (choice == 1) {
            System.out.println("Вывод значения площади подматрицы в файл...");

            do {
                isIncorrect = false;
                try {
                    FileWriter writer = new FileWriter(path);
                    writer.write(area + "\n");
                    writer.close();
                } catch (IOException e) {
                    isIncorrect = true;
                    System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                    path = inputPathToFile();
                }
            } while (isIncorrect);

            System.out.println("Данные успешно записаны в файл!");
        }
    }
    public static int[][] processUserInput() throws FileNotFoundException {
        int length, width;
        int choiceForInput;
        int[][] matrix = new int[0][];
        String pathToIn;

        System.out.println("Вы желаете ввести данные с консоли(0) или взять данные из файла(1)?");
        choiceForInput = getVerificationOfChoice();

        if (choiceForInput == 0) {
            length = readLengthFromConsole();
            width = readWidthFromConsole();
            matrix = fillMatrixFromConsole(length, width);
        }
        if (choiceForInput == 1) {
            pathToIn = inputPathToFile();
            length = readLengthFromFile(pathToIn);
            width = readWidthFromFile(pathToIn);
            matrix = fillMatrixFromFile(length, width, pathToIn);
        }

        return matrix;
    }

    public static void processUserOutput(int length, int width, int[][] matrix, int area) {
        int choiceForOutput;
        String pathToOut = "";

        System.out.println("Вы желаете получить результат в консоли(0) или в файле(1)?");
        choiceForOutput = getVerificationOfChoice();

        if (choiceForOutput == 1)
            pathToOut = inputPathToFile();
        outputLength(choiceForOutput, length, pathToOut);
        outputWidth(choiceForOutput, width, pathToOut);
        outputMatrix(choiceForOutput, pathToOut, matrix, length, width);
        outputArea(choiceForOutput, pathToOut, area);
    }

    public static void main (String[] args) throws FileNotFoundException {
        int row = 0;
        int col = 0;
        outputTaskInfo();
        int[][] matrix = processUserInput();
        int area = findArea(matrix, row, col);
        processUserOutput(matrix.length, matrix[0].length, matrix, area);

        scan.close();
    }
}