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

public class Main {
    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        int[][] matrix;
        int resultOfCalc;

        taskEssence();
        matrix = sourceChoice();
        matrix = sotringMatrix(matrix);
        output(matrix);
    }
    public static int exceptionRead(int i, int j) {
        boolean isIncorrect;
        int number;

        number = 0;
        do {
            isIncorrect = false;
            System.out.print("Введите " + (i+1) + "," + (j+1) + " элемент матрицы: ");
            try {
                number = Integer.parseInt(scanner.nextLine());
            } catch (NumberFormatException exception) {
                System.err.println("Неверный ввод данных!");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return number;
    }
    public static void taskEssence() {
        System.out.println("Данная программа сортирует элементы четных строк матрицы по убыванию.");
    }
    public static int[][] sourceChoice() {
        int choiceNumber;
        boolean isIncorrect;
        int[][] matrix = new int[0][0];
        choiceNumber = -1;

        System.out.println("Выберите, откуда будут вводиться данные: ");
        do {
            isIncorrect = false;
            System.out.println("Введите 0, если с консоли; 1, если с файла");
            try {
                choiceNumber = Integer.parseInt(scanner.nextLine());
            } catch (NumberFormatException exception) {
                isIncorrect = true;
                System.err.println("Неверный ввод данных!");
            }
            if (((choiceNumber != 0) && (choiceNumber != 1)) || (isIncorrect == true)) {
                isIncorrect = true;
                System.err.println("Число должно быть или 0, или 1");
            }
        } while (isIncorrect);
        if (choiceNumber == 0) {
            matrix = fromConsole();
        } else {
            matrix = fromFile();
        }
        return matrix;
    }
    public static int[][] fromFile() {
        String path;
        int size;
        int[][] matrix;

        System.out.println("При записи данных из файла, учтите, что на первой строке написан порядок матрицы, а далее с новой строки прописывается сама матрица.");
        path = pathChoice();
        size = sizeFromFile(path);
        matrix = new int[size][size];
        matrix = matrixReadFile(path, size, matrix);
        outputMatrix(matrix, size);

        return matrix;
    }
    public static String pathChoice() {
        String path;
        boolean isIncorrect;

        do {
            isIncorrect = false;
            System.out.println("Введите путь к файлу: ");
            path = scanner.nextLine();

            File file = new File(path);
            if (!file.exists()) {
                System.out.println("По указанном пути файл не найден.");
                isIncorrect = true;
            } else if (!getExtension(path).equals("txt")) {
                System.err.println("Ошибка, неправильный тип файла!");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return path;

    }
    public static String getExtension(String path) {
        int pos = path.lastIndexOf('.');
        if (pos <= 0) {
            return "";
        }
        return path.substring(pos + 1);
    }
    public static int sizeFromFile(String path) {
        int size;
        boolean isIncorrect;

        System.out.println("Считывание размера матрицы...");
        size = 0;

        isIncorrect = false;
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            try {
                size = Integer.parseInt(reader.readLine());
            } catch(NumberFormatException exception) {
                isIncorrect = true;
            }
            if ((size < 1) || (isIncorrect == true)) {
                isIncorrect = true;
                System.out.println("Неверный ввод данных! Впишите данные с клавиатуры.");
                size = sizeFromConsole();
            }
            else {
                System.out.println(size);
            }
        } catch (IOException ioException) {
            isIncorrect = true;
        }


        return size;

    }
    public static int[][] matrixReadFile(String path, int size, int[][] matrix) {
        boolean isIncorrect;

        System.out.println("Считывание матрицы...");

    isIncorrect = false;
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            reader.readLine();
            for (int i = 0; i < size; i++) {
                String[] elements = reader.readLine().split(" ");
                for (int j = 0; j < size; j++) {
                    try {
                        matrix[i][j] = Integer.parseInt(elements[j]);
                    } catch (NumberFormatException exception) {
                        System.out.println("Неверный ввод данных! Запишите данные с клавиатуры.");
                        matrix[i][j] = exceptionRead(i, j);
                    }
                }
            }
        } catch (IOException ioException) {
            isIncorrect = true;
            System.err.println("Ошибка!");
        }


        return matrix;
    }
    public static void output(int[][] matrix) {
        String path;
        boolean isIncorrect;

        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.print(" ");
            }
            System.out.println();
        }
        path = outputPath();
        do {
            isIncorrect = false;
            try (FileWriter writer = new FileWriter(path, true)) {
                writer.write("Обновленная матрица: \n" );
                for (int i = 0; i < matrix.length; i++) {
                    for (int j = 0; i < matrix.length; j++) {
                        writer.write(matrix[i][j]);
                        writer.write(" ");
                    }
                    writer.write("\n");
                }
            } catch (IOException ioException) {
                System.err.println("Ошибка при записи в файл");
                isIncorrect = true;
            }
        } while (isIncorrect);
        System.out.println("Данные записаны в файл.");
    }
    public static int[] bubbleSort(int[] row, int size) {
        for (int i = 0; i < size - 1; ++i) {
            for (int j = 0; j < size - 1 - i; ++j) {
                if (row[j] < row[j + 1]) {
                    int temp = row[j];
                    row[j] = row[j + 1];
                    row[j + 1] = temp;
                }
            }
        }
        return row;
    }
    public static int[][] sotringMatrix(int[][] matrix) {
        int size;
        size = matrix[0].length;
        for (int i = 1; i < size; i += 2) {
            matrix[i] = bubbleSort(matrix[i], size);
        }
        return matrix;
    }
    public static String outputPath() {
        String path;
        boolean isIncorrect;

        do {
            isIncorrect = false;
            System.out.println("Введите путь к файлу для вывода: ");
            System.out.println();
            path = scanner.nextLine();

            File file = new File(path);
            if (!file.exists()) {
                System.out.println("По указанном пути файл не найден.");
                isIncorrect = true;
            } else if (!getExtension(path).equals("txt")) {
                System.err.println("Ошибка, неправильный тип файла!");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return path;
    }
    public static int[][] fromConsole() {
        int size;
        int[][] matrix;
        size = sizeFromConsole();
        matrix = new int[size][size];
        matrix = matrixReadConsole(size, matrix);
        outputMatrix(matrix, size);

        return matrix;

    }
    public static int sizeFromConsole() {
        boolean isIncorrect;
        int size;

        size = 0;
        do {
            isIncorrect = false;
            System.out.print("Введите порядок матрицы: ");
            try {
                size = Integer.parseInt(scanner.nextLine());
                if (!isIncorrect && (size < 1)) {
                    System.err.println("Неверный ввод данных!");
                    isIncorrect = true;
                }
            } catch (NumberFormatException exception) {
                System.err.println("Неверный ввод данных!");
                isIncorrect = true;
            }

        } while (isIncorrect);

        return size;
    }
    public static int[][] matrixReadConsole(int size, int[][] matrix) {
        boolean isIncorrect;
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                do {
                    isIncorrect = false;
                    System.out.print("Введите элемент " + (i+1) + "," + (j+1) + " элемент матрицы: ");
                    try {
                        matrix[i][j] = Integer.parseInt(scanner.nextLine());
                    } catch (NumberFormatException exception) {
                        System.err.println("Неверный ввод данных!");
                        isIncorrect = true;
                    }

                } while (isIncorrect);
            }
        }
        return matrix;

    }
    public static void outputMatrix(int[][] matrix, int size) {
        System.out.println("Введенная матрица:");
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                System.out.print(matrix[i][j]);
                System.out.print(" ");
            }
            System.out.println();
        }
    }
}