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

import static java.lang.Math.abs;

public class Main {
    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {
        writeTask();
        System.out.print("Выберите способ ввода данных (1 - через консоль, 2 - с помощью файлов): ");
        int choice = chooseInputOutputMethod();
        int[][] matrix = getMatrix(choice);
        int answer = findMatrixNorm(matrix);
        System.out.print("Выберите способ вывода данных (1 - через консоль, 2 - с помощью файлов): ");
        choice = chooseInputOutputMethod();
        outputResult(choice, answer);
        scan.close();
    }

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

    public static int takeMatrixOrderFromConsole() {
        final int MAX_ORDER = 10;
        final int MIN_ORDER = 2;
        boolean isNotCorrect;
        int order = 0;
        do {
            isNotCorrect = false;
            System.out.print("Введите порядок квадратной матрицы: ");
            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("Введённое число не входит в допустимый диапазон. Повторите попытку...");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return order;
    }

    public static int[][] createMatrixFromConsole() {
        final int MIN_ELEMENT = -2147483648;
        final int MAX_ELEMENT = 2147483647;
        int order = takeMatrixOrderFromConsole();
        int[][] matrix = new int[order][order];
        boolean isNotCorrect;
        for (int i = 0; i < order; i++) {
            for (int j = 0; j < order; j++) {
                do {
                    isNotCorrect = false;
                    System.out.print("Введите элемент " + (i + 1) + " строки " + (j + 1) + " столбца матрицы: ");
                    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 outputMatrixInConsole(int[][] matrix) {
        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 String takePathToFile(){
        String path;
        boolean isNotCorrect;
        do {
            isNotCorrect = false;
            System.out.println("Введите путь к файлу: ");
            path = scan.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                System.out.println("Не удалось найти файл по заданному пути. Повторите попытку...");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return path;
    }

    public static int[][] takeMatrixFromFile() {
        System.out.println("Требуется файл для чтения. ");
        String path = takePathToFile();
        final int MAX_ELEMENT = 2147483647;
        final int MIN_ELEMENT = -2147483648;
        final int MAX_ORDER = 10;
        final int MIN_ORDER = 2;
        boolean isNotCorrect;
        int order = 0;
        int[][] matrix;
        do {
            do {
                isNotCorrect = false;
                try (Scanner fileReader = new Scanner(new File (path))) {
                    try {
                        order = Integer.parseInt(fileReader.nextLine());
                    } catch (NumberFormatException e) {
                        System.out.print("Некорректный порядок матрицы. ");
                        isNotCorrect = true;
                    }
                    if ((!isNotCorrect) && ((order < MIN_ORDER) || (order > MAX_ORDER))) {
                        System.out.print("Порядок матрицы не входит в допустимый диапазон. ");
                        isNotCorrect = true;
                    }
                } catch (IOException e) {
                    System.out.print("Не удалось открыть файл по заданному пути. ");
                    isNotCorrect = true;
                }
                if (isNotCorrect) {
                    System.out.println("Повторите попытку...");
                    path = takePathToFile();
                }
            } while (isNotCorrect);
            matrix = new int[order][order];
            int j;
            int i = 0;
            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 = takePathToFile();
            }
        } while (isNotCorrect);
        return matrix;
    }

    public static int[] calculateAbsSums(int[][] matrix) {
        int[] absSums = new int[matrix.length];
        int sum;
        for (int i = 0; i < matrix.length; i++) {
            sum = 0;
            for (int j = 0; j < matrix.length; j++) {
                sum += abs(matrix[i][j]);
            }
            absSums[i] = sum;
        }
        return absSums;
    }

    public static int findMatrixNorm(int[][] matrix) {
        int[] absSums = calculateAbsSums(matrix);
        int norm = absSums[0];
        for (int i = 0; i < matrix.length; i++) {
            if (absSums[i] > norm) {
                norm = absSums[i];
            }
        }
        return norm;
    }

    public static int chooseInputOutputMethod() {
        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 outputAnswerInFile(int answer) {
        System.out.print("Требуется файл для записи. ");
        String path = takePathToFile();
        boolean isNotCorrect;
        do {
            isNotCorrect = false;
            try (FileWriter fileWriter = new FileWriter(new File (path))) {
                fileWriter.write("Полученная норма матрицы: " + answer);
            } catch (IOException e) {
                System.out.print("Не удалось получить доступ к файлу. ");
                isNotCorrect = true;
            }
            if (isNotCorrect) {
                System.out.println("Повторите попытку...");
                path = takePathToFile();
            }
        } while (isNotCorrect);
        System.out.println("Норма матрицы записана в файл!");
    }

    public static int[][] getMatrix(int choice) {
        int[][] matrix;
        if (choice == 1) {
            matrix = createMatrixFromConsole();
            outputMatrixInConsole(matrix);
        } else {
            matrix = takeMatrixFromFile();
            outputMatrixInConsole(matrix);
        }
        return matrix;
    }

    public static void outputResult(int choice, int answer) {
        if (choice == 1) {
            System.out.println("Полученная норма матрицы: " + answer);
        } else {
            outputAnswerInFile(answer);
        }
    }
}