java23

import java.io.*;
import java.nio.file.*;
import java.util.Scanner;
public class Main {
    final static int MIN_N = 2;
    final static int MAX_N = 100;
    final static int MIN_A = -10000;
    final static int MAX_A = 10000;
    static Scanner in = new Scanner(System.in);

    public static int inputAndCheckChoice() {
        boolean isIncorrect;
        isIncorrect = false;
        int choice;
        choice = 0;
        do {
            System.out.println("Введите ваш выбор.");
            try {
                choice = Integer.parseInt(in.nextLine());
            } catch (NumberFormatException e) {
                isIncorrect = true;
                System.err.println("Некорректный ввод.");
            }
            if (choice != 1 && choice != 2) {
                System.err.println("Введите 1 или 2.");
            } else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return choice;
    }

    public static int inputAndCheckN() {
        boolean isIncorrect;
        int n;
        n = 0;
        do {
            isIncorrect = false;
            System.out.println("Введите порядок матрицы n: ");
            try {
                n = Integer.parseInt(in.nextLine());
            } catch (NumberFormatException e) {
                isIncorrect = true;
                System.err.println("Некорректный ввод. Введите целое число.");
            }
            if (!isIncorrect && (n < MIN_N || n > MAX_N)) {
                isIncorrect = true;
                System.err.println("Диапазон значений n от " + MIN_N + " до " + MAX_N + ".");
            }
        } while (isIncorrect);
        return n;
    }

    public static boolean isEof(final String fileName) {
        boolean isEof;
        isEof = false;
        try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
            String line = br.readLine();
            if (line != null) {
                isEof = true;
            }
        } catch (IOException e) {
            System.err.println("Ошибка.");
        }
        return isEof;
    }

    public static String requestFileNameForReading() {
        boolean isIncorrect;
        String fileName;
        isIncorrect = true;
        File tempFile;
        Path path;
        do {
            System.out.println("Введите относительный путь к файлу.");
            fileName = in.nextLine();
            path = Paths.get(fileName);
            tempFile = new File(fileName);
            if (!tempFile.exists()) {
                System.err.println("Файл не существует.");
            } else if (fileName.length() < 5 || !fileName.endsWith(".txt")) {
                System.err.println("Файл не является текстовым.");
            } else if (!Files.isReadable(path)) {
                System.err.println("Этот файл невозможно открыть для чтения.");
            } else if (!isEof(fileName)) {
                System.err.println("Этот файл пустой.");
            } else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return fileName;
    }

    public static String requestFileNameForWriting() {
        boolean isIncorrect;
        String fileName;
        isIncorrect = true;
        File tempFile;
        Path path;
        do {
            System.out.println("Введите относительный путь к файлу.");
            fileName = in.nextLine();
            path = Paths.get(fileName);
            tempFile = new File(fileName);
            if (!tempFile.exists()) {
                System.err.println("Файл не существует.");
            } else if (fileName.length() < 5 || !fileName.endsWith(".txt")) {
                System.err.println("Файл не является текстовым.");
            } else if (!Files.isWritable(path)) {
                System.err.println("Этот файл невозможно открыть для записи.");
            } else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return fileName;
    }

    public static boolean checkSize(boolean isIncorrect, final int size, final int count, final String fileName) {
        String tempLine;
        String[] doubleInString;
        if ((!isIncorrect) && ((size * size) == count) && ((size >= MIN_N) && (size <= MAX_N))) {
            double[][] tempMatrix = new double[size][size];
            try (BufferedReader fReader = new BufferedReader(new FileReader(fileName))) {
                for (int i = 0; i < size; i++) {
                    tempLine = fReader.readLine();
                    if (tempLine != null) {
                        doubleInString = tempLine.split(" ");
                        for (int j = 0; j < size; j++) {
                            tempMatrix[i][j] = Double.parseDouble(doubleInString[j]);
                            if (tempMatrix[i][j] < MIN_A || tempMatrix[i][j] > MAX_A) {
                                isIncorrect = true;
                            }
                        }
                    }
                }
                if (isIncorrect) {
                    System.err.println("Элементы матрицы выходят за диапазон допустимых значений.");
                }

            } catch (NumberFormatException e) {
                System.err.println("Матрица содержит данные неверного типа.");
                isIncorrect = true;
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
            }
        } else {
            System.err.println("Матрица должна быть квадратной. Диапазон значений n: " + MIN_N + ".." + MAX_N + ".");
            isIncorrect = true;
        }
        return isIncorrect;
    }

    public static int readSizeFromFile(String fileName) {
        boolean isIncorrect;
        int size;
        int count;
        String[] doubleInString;
        String tempLine;
        do {
            count = 0;
            isIncorrect = false;
            try (BufferedReader fReader = new BufferedReader(new FileReader(fileName))) {
                while ((tempLine = fReader.readLine()) != null) {
                    doubleInString = tempLine.split(" ");
                    count += doubleInString.length;
                }
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
            }
            size = (int) Math.sqrt(count);
            isIncorrect = checkSize(isIncorrect, size, count, fileName);
            if (isIncorrect) {
                fileName = requestFileNameForReading();
            }
        } while (isIncorrect);
        return size;
    }

    public static double[][] readMatrix(final int size, String fileName) {
        double[][] matrix = new double[size][size];
        boolean isIncorrect;
        String[] doubleInString;
        String tempLine;
        do {
            isIncorrect = false;
            try (BufferedReader fReader = new BufferedReader(new FileReader(fileName))) {
                if (matrix != null) {
                    for (int i = 0; i < size; i++) {
                        tempLine = fReader.readLine();
                        if (tempLine != null) {
                            doubleInString = tempLine.split(" ");
                            for (int j = 0; j < size; j++) {
                                matrix[i][j] = Double.parseDouble(doubleInString[j]);
                                if (matrix[i][j] < MIN_A || matrix[i][j] > MAX_A) {
                                    isIncorrect = true;
                                }
                            }
                        }
                    }
                    if (isIncorrect) {
                        System.err.println("Элементы матрицы выходят за диапазон допустимых значений.");
                    }
                } else {
                    System.err.println("Матрица не содержит элементов.");
                    isIncorrect = true;
                }
            } catch (NumberFormatException e) {
                System.err.println("Некорректный тип данных.");
                isIncorrect = true;
                matrix = null;
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
                matrix = null;
            }
            if (isIncorrect) {
                fileName = requestFileNameForReading();
            }
        } while (isIncorrect);
        return matrix;
    }

    public static double[][] createMatrix(final int n) {
        double[][] matrix = new double[n][n];
        boolean isIncorrect;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                do {
                    isIncorrect = false;
                    System.out.println("Введите элемент матрицы: ");
                    try {
                        matrix[i][j] = Double.parseDouble(in.nextLine());
                    } catch (NumberFormatException e) {
                        isIncorrect = true;
                        System.err.println("Некорректный ввод. Введите число.");
                    }
                    if (!isIncorrect && (matrix[i][j] < MIN_A || matrix[i][j] > MAX_A)) {
                        isIncorrect = true;
                        System.err.println("Диапазон значений A от " + MIN_A + " до " + MAX_A + ".");
                    }
                } while (isIncorrect);
            }
        }
        return matrix;
    }

    public static double sumElements(double[][] matrix, int n) {
        double sum;
        sum = 0.0;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (matrix[i][j] > 0) {
                    sum += matrix[i][j];
                }
            }
        }
        return sum;
    }

    public static boolean writeToFile(final String fileName, final double sum) {
        boolean isIncorrect;
        isIncorrect = true;
        String result = Double.toString(sum);
        try (BufferedWriter fWriter = new BufferedWriter(new FileWriter(fileName))) {
            fWriter.write(result);
            System.out.println("Результат выведен в файле.");
            isIncorrect = false;
        } catch (IOException e) {
            System.err.println("Непредвиденная ошибка.");
        }
        return isIncorrect;
    }

    public static void main(String[] args) {
        int choice;
        int n;
        double sum;
        boolean isIncorrect;
        String fileName;
        System.out.println("Данная программа считает сумму положительных элементов матрицы порядка n, стоящих под главной диагональю.\nДиапазон значений порядка матрицы n: "
                + MIN_N + "..." + MAX_N + "\nДиапазон для значений элементов матрицы : " + MIN_A + "..." +
                MAX_A + "\nОткуда вы хотите вводить данные ? \n1 - консоль, 2 - файл.");
        choice = inputAndCheckChoice();
        double[][] matrix;
        if (choice == 1) {
            n = inputAndCheckN();
            matrix = createMatrix(n);
        } else {
            fileName = requestFileNameForReading();
            n = readSizeFromFile(fileName);
            matrix = readMatrix(n, fileName);
        }
        sum = sumElements(matrix, n);
        System.out.println("Куда Вы хотите вывести результат? \n1 - консоль, 2 - файл.");
        choice = inputAndCheckChoice();
        if (choice == 1) {
            System.out.println("Сумма равна " + sum);
        } else {
            do {
                fileName = requestFileNameForWriting();
                isIncorrect = writeToFile(fileName, sum);
            } while (isIncorrect);
        }
        in.close();
    }
}