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

public class lab23 {

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

    public static void main(String[] args)
    {
            int userWay, numberOfLines, numberOfColumns, numberOfSortedLines;
            System.out.println("Программа считает количество строк данной матрицы, которые упорядочены по возрастанию.\n");
            userWay = chooseWayOfInput();
            int[][] matrix = receiveMatrix(userWay);
            numberOfLines = matrix.length;
            numberOfColumns = matrix[0].length;
            numberOfSortedLines = counterOfSortedLines(matrix, numberOfLines, numberOfColumns);
            resultOutput(numberOfSortedLines);
            userWayOfOutput(numberOfSortedLines);
            consoleScanner.close();
            System.out.println("Программа завершена");
    }

    public static int inputNumber(int minNumber, int maxNumber) {
        Scanner consoleScanner = new Scanner(System.in);
        boolean isIncorrect;
        int number = 0;
        do {
            isIncorrect = false;
            try {
                number = Integer.parseInt(consoleScanner.nextLine());
            } catch (Exception ex) {
                System.out.println("Число должно быть целым.");
                isIncorrect = true;
            }
            if (!isIncorrect && (number < minNumber || number > maxNumber)) {
                System.out.println("Число должно быть не меньше " + minNumber + " и не больше, чем " + maxNumber);
                isIncorrect = true;
            }
        } while (isIncorrect);
        return number;
    }

    static int chooseWayOfInput() {
        int userWay;
        do {
            System.out.println("Выберите способ ввода: \nНажмите '1', если хотите ввести матрицу через консоль.\nНажмите '2', если хотите считать матрицу из файла.");
            userWay = inputNumber(1, 2);
        } while (userWay != 1 && userWay != 2);
        return userWay;
    }

    static String inputPathToFile() {
        System.out.println("Введите путь к файлу:");
        boolean isIncorrect, isCorrect;
        String path;
        do {
            do {
                isIncorrect = false;
                path = consoleScanner.nextLine();
                try {
                    new FileReader(path);
                } catch (FileNotFoundException e) {
                    System.out.println("Файл не найден. Введите путь к файлу еще раз:");
                    isIncorrect = true;
                }
            } while (isIncorrect);
            isCorrect = checkExtension(path);
        }while(!isCorrect);
        return path;
    }

    static int receiveNumberOfLinesFromFile(String path, Scanner fileScanner) {
        boolean isIncorrect;
        int numberOfLines;
        do {
            isIncorrect = false;
            numberOfLines = fileScanner.nextInt();
            if (numberOfLines < 1)
            {
                isIncorrect = true;
                System.out.println("Некорректные данные в файле.");
                path = inputPathToFile();
            }
        } while (isIncorrect);
        return numberOfLines;
    }

    static int receiveNumberOfColumnsFromFile(String path, Scanner fileScanner) {
        boolean isIncorrect;
        int numberOfColumns;
        do {
            isIncorrect = false;
            numberOfColumns = fileScanner.nextInt();
            if (numberOfColumns < 1)
            {
                isIncorrect = true;
                System.out.println("Некорректные данные в файле.");
                path = inputPathToFile();
            }
        } while (isIncorrect);
        return numberOfColumns;
    }

    static int[][] receiveMatrixFromFile(String path) {
        File file = new File(path);
        int[][] matrix = null;
        try {
            Scanner fileScanner = new Scanner(file);
            int numberOfLines = receiveNumberOfLinesFromFile(path, fileScanner);
            int numberOfColumns = receiveNumberOfColumnsFromFile(path, fileScanner);
            matrix = new int[numberOfLines][numberOfColumns];
            for (int i = 0; i < numberOfLines; i++) {
                for (int j = 0; j < numberOfColumns; j++) {
                    matrix[i][j] = fileScanner.nextInt();
                }
            }
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return matrix;
    }

    static int[][] receiveMatrixFromConsole(int numberOfLines, int numberOfColumns) {
        int[][] matrix = new int[numberOfLines][numberOfColumns];
        for (int i = 0; i < numberOfLines; i++)
        {
            for (int j = 0; j < numberOfColumns; j++)
            {
                System.out.println("Введите значение элемента[" + (i + 1) + "]" + "[" + (j + 1) + "]");
                matrix[i][j] = inputNumber(-100, 100);
            }
        }
        return matrix;
    }

    static int counterOfSortedLines(int[][] matrix, int numberOfLines, int numberOfColumns) {
        int counter, numberOfSortedLines;
        numberOfSortedLines = 0;
        for (int i = 0; i < numberOfLines; i++)
        {
            counter = 0;
            for (int j = 1; j < numberOfColumns; j++)
            {
                if (matrix[i][j - 1] < matrix[i][j])
                {
                    counter++;
                }
            }
            if (counter == numberOfColumns - 1)
            {
                numberOfSortedLines++;
            }
        }
        return numberOfSortedLines;
    }

    static void resultOutput(int numberOfSortedLines) {
        System.out.println( "Количество строк, отсортированных по возрастанию: " + numberOfSortedLines);
    }

    static int inputNumberOfLines() {
        int numberOfLines;
        System.out.println("Введите количество строк:");
        numberOfLines = inputNumber(2, 5);
        return numberOfLines;
    }

    static int inputNumberOfColumns() {
        int numberOfColumns;
        System.out.println("Введите количество столбцов:");
        numberOfColumns = inputNumber(2, 5);
        return numberOfColumns;
    }

    static int[][] receiveMatrix(int userWay) {
        String path;
        int numberOfLines, numberOfColumns;
        int[][] matrix = new int[0][0];
        switch (userWay)
        {
            case 1: {
                numberOfLines = inputNumberOfLines();
                numberOfColumns = inputNumberOfColumns();
                matrix = receiveMatrixFromConsole(numberOfLines, numberOfColumns);
                break;
            }
            case 2: {
                path = inputPathToFile();
                matrix = receiveMatrixFromFile(path);
                break;
            }
        }
        return matrix;
    }

    static boolean checkPermission(String path) {
        File file = new File(path);
        if (!file.canWrite()) {
            System.out.println("Файл закрыт для записи");
            return false;
        }
        return true;
    }

    static boolean checkExtension(String path) {
        int lastIndex;
        lastIndex = path.length() - 1;
        char[] pathToFile = path.toCharArray();
            if (pathToFile[lastIndex] != 't' || pathToFile[lastIndex - 1] != 'x' || pathToFile[lastIndex - 2] != 't' || pathToFile[lastIndex - 3] != '.')
            {
                System.out.println("Файл имеет неверное расширение. ");
                return false;
            }
            return true;
    }

    static void checkOutputFile(String path) {
        boolean isIncorrect;
        do {
            isIncorrect = false;
            if (!checkPermission(path) || !checkExtension(path)) {
                isIncorrect = true;
                path = inputPathToFile();
            }
        } while (isIncorrect);
    }

    static void printResultInFile(String path, int numberOfSortedLines) {
        try {
            FileWriter writer = new FileWriter(path);
            writer.write("Количество отсортированных по возрастанию строк: " + numberOfSortedLines);
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void userWayOfOutput(int numberOfSortedLines) {
        String userWay;
        char checkUserWay;
        System.out.println("Если хотите записать результат в файл, введите '1'. Если не хотите - введите другой символ:");
        userWay = consoleScanner.nextLine();
        checkUserWay = userWay.charAt(0);
        if (checkUserWay == '1')
        {
            String path = inputPathToFile();
            checkOutputFile(path);
            printResultInFile(path, numberOfSortedLines);
            System.out.println("Результат записан в файл. \n");
        }
    }
}