program lab23;

{$APPTYPE CONSOLE}
{$R *.res}

uses System.SysUtils;

Function CheckExtension(Path: String): Boolean; forward;

Function CheckPermission(Path: String): Boolean; forward;

type
    TMatrix = array of array of Integer;

Function InputNumber(MinNumber, MaxNumber: Integer): Integer;

var
    IsCorrect: Boolean;
    Number: Integer;

begin
    repeat
        IsCorrect := true;
        try
            Readln(Number);
        except
            Writeln('Нужно ввести целое число, которое не меньше ', MinNumber,
              ' и не больше ', MaxNumber);
            IsCorrect := false;
        end;
        if IsCorrect and ((Number < MinNumber) or (Number > MaxNumber)) then
        begin
            Writeln('Нужно ввести целое число, которое не меньше ', MinNumber,
              ' и не больше ', MaxNumber);
            IsCorrect := false;
        end;
    until IsCorrect;
    InputNumber := Number;
end;

Function ChooseWayOfInput(): Integer;

var
    UserWay: Integer;

begin
    Repeat
        Writeln('Выберите способ ввода:'#13#10'Нажмите "1", если хотите ввести матрицу через консоль.'#13#10'Нажмите "2", если хотите считать матрицу из файла.');
        UserWay := InputNumber(1, 2);
    Until (UserWay = 1) or (UserWay = 2);
    ChooseWayOfInput := UserWay;
end;

function InputPathToFile(): String;

var
    Path: String;
    IsCorrect, Flag: Boolean;
    NewFile: TextFile;
begin
    Writeln('Введите путь к файлу:');
    repeat
        repeat
            IsCorrect := true;
            Readln(Path);
            Try
                AssignFile(NewFile, Path);
                Reset(NewFile);
            Except
                Writeln('Ошибка! Путь указан неверно. Введите его заново.');
                IsCorrect := false;
            End
        Until (IsCorrect);
        Flag := CheckExtension(Path);
    until Flag;

    InputPathToFile := Path;
end;

Function ReceiveMatrixFromConsole(): TMatrix;

var
    NumberOfLines, NumberOfColumns, i, j: Integer;
    Matrix: TMatrix;

begin
    Writeln('Введите количество строк матрицы:');
    NumberOfLines := InputNumber(2, 5);
    Writeln('Введите количество столбцов матрицы:');
    NumberOfColumns := InputNumber(2, 5);
    Setlength(Matrix, NumberOfLines, NumberOfColumns);
    Dec(NumberOfLines);
    Dec(NumberOfColumns);
    for i := 0 to NumberOfLines do
    begin
        for j := 0 to NumberOfColumns do
        begin;
            Writeln('Введите элемент матрицы[', i + 1, '][', j + 1, ']: ');
            Matrix[i][j] := InputNumber(-100, 100);
        end;
    end;
    ReceiveMatrixFromConsole := Matrix;
end;

Function ReceiveMatrixFromFile(Path: String): TMatrix;

var
    InputFile: TextFile;
    Matrix: TMatrix;
    NumberOfLines, NumberOfColumns, i, j: Integer;
    IsCorrect: Boolean;

begin;
    repeat
        IsCorrect := true;
        Assign(InputFile, Path);
        Reset(InputFile);
        Read(InputFile, NumberOfLines);
        Readln(InputFile, NumberOfColumns);
        Setlength(Matrix, NumberOfLines, NumberOfColumns);
        Dec(NumberOfLines);
        Dec(NumberOfColumns, 2);
        try
            for i := 0 to NumberOfLines do
            begin
                for j := 0 to NumberOfColumns do
                begin
                    Read(InputFile, Matrix[i][j]);
                end;
                Readln(InputFile, Matrix[i][NumberOfColumns + 1]);
            end;
        except
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;
    until IsCorrect;
    ReceiveMatrixFromFile := Matrix;
end;

procedure CheckMatrix(var Path: String);
var
    InputFile: TextFile;
    Matrix: TMatrix;
    Line: String;
    NumberOfLines, NumberOfColumns, i: Integer;
    IsCorrect: Boolean;
begin
    repeat
        IsCorrect := true;
        Assign(InputFile, Path);
        try
            Reset(InputFile);
            Read(InputFile, NumberOfLines);
            Readln(InputFile, NumberOfColumns);
        except
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;

        if (IsCorrect) and ((NumberOfLines < 2) or (NumberOfColumns < 2) or
          (NumberOfLines > 5) or (NumberOfColumns > 5)) then
        begin
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;

        if IsCorrect then
        begin
            Setlength(Matrix, NumberOfLines, NumberOfColumns);
            i := 0;
            While (IsCorrect) and (i < NumberOfLines) do
            begin
                Readln(InputFile, Line);
                if Length(Line.Split([' '])) <> NumberOfColumns then
                begin
                    IsCorrect := false;
                    Writeln('Некорректные данные в файле!');
                    Close(InputFile);
                    Path := InputPathToFile();
                end;
                Inc(i);
            end;
        end;
    until IsCorrect;
    Close(InputFile);
end;

Function ReceiveMatrix(UserWay: Integer): TMatrix;

var
    Path: String;
    Matrix: TMatrix;

begin;
    case UserWay of
        1:
            begin
                Matrix := ReceiveMatrixFromConsole();
            end;
        2:
            begin
                Path := InputPathToFile();
                CheckMatrix(Path);
                Matrix := ReceiveMatrixFromFile(Path);
            end;
    end;
    ReceiveMatrix := Matrix;

end;

Function CounterOfSortedLines(Matrix: TMatrix): Integer;

var
    Counter, NumberOfSortedLines, NumberOfLines, NumberOfColumns, i, j: Integer;

begin
    NumberOfSortedLines := 0;
    NumberOfLines := Length(Matrix);
    NumberOfColumns := Length(Matrix[0]);
    Dec(NumberOfLines);
    Dec(NumberOfColumns);
    for i := 0 to NumberOfLines do
    begin
        Counter := 0;
        for j := 1 to NumberOfColumns do
        begin
            if (Matrix[i][j - 1] < Matrix[i][j]) then
            begin
                Inc(Counter);
            end;
        end;
        if (Counter = NumberOfColumns) then
            Inc(NumberOfSortedLines);
    end;
    CounterOfSortedLines := NumberOfSortedLines;
end;

Function CheckExtension(Path: String): Boolean;

var
    RigthExtension: Boolean;

begin
    if (ExtractFileExt(Path) = '.txt') then
        RigthExtension := true
    else
    begin
        Writeln('Неверное расширение файла.');
        RigthExtension := false;
    end;
    CheckExtension := RigthExtension;
end;

Function CheckPermission(Path: String): Boolean;

var
    OutputFile: TextFile;
    RightPermission: Boolean;

begin
    Assign(OutputFile, Path);
    RightPermission := true;
    try
        Rewrite(OutputFile);
        Close(OutputFile);
    except
        Writeln('Файл закрыт для записи.');
        RightPermission := false;
    end;
    CheckPermission := RightPermission;
end;

Procedure PrintResultToFile(Path: String; NumberOfSortedLines: Integer);

var
    OutputFile: TextFile;

begin
    Assign(OutputFile, Path);
    Rewrite(OutputFile);
    Writeln(OutputFile, 'Количество строк, отсортированных по возрастанию: ',
      NumberOfSortedLines);
    Close(OutputFile);
end;

Procedure UserWayOfOutput(NumberOfSortedLines: Integer);

var
    UserWay: Char;
    Path: String;

begin;
    Writeln('Если хотите записать результат в файл, введите "1". Если не хотите - введите другой символ:');
    Readln(UserWay);
    if (UserWay = '1') then
    begin;
        repeat
            Path := InputPathToFile();
        until (CheckPermission(Path));
        PrintResultToFile(Path, NumberOfSortedLines);
        Writeln('Результат записан в файл.');
    end;
end;

Procedure PrintResult(NumberOfSortedLines: Integer);

begin;
    Writeln('Количество строк, отсортированных по возрастанию: ',
      NumberOfSortedLines);
end;

Procedure Main();

var
    UserWay, NumberOfSortedLines: Integer;
    Matrix: TMatrix;

begin
    Writeln('Программа считает количество строк данной матрицы, которые упорядочены по возрастанию.');
    UserWay := ChooseWayOfInput();
    Matrix := ReceiveMatrix(UserWay);
    NumberOfSortedLines := CounterOfSortedLines(Matrix);
    PrintResult(NumberOfSortedLines);
    UserWayOfOutput(NumberOfSortedLines);
    Writeln('Программа завершена.');
    Readln;
end;

begin
    Main();

end.