program lab23;

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

uses System.SysUtils;

Function CheckExtension(var 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;
begin
    Writeln('Введите путь к файлу:');
    repeat
        repeat
            IsCorrect := true;
            Readln(Path);
            if not FileExists(Path) then
            begin
                IsCorrect := false;
                Writeln('Файл не найден. Введите путь к файлу еще раз:');
            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;

Function ReceiveMatrix(UserWay: Integer): TMatrix;

var
    Path: String;
    Matrix: TMatrix;

begin;
    case UserWay of
        1:
            begin
                Matrix := ReceiveMatrixFromConsole();
            end;
        2:
            begin
                Path := InputPathToFile();
                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(var 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 CheckOutputFile(var Path: String);

var
    IsCorrect: Boolean;

begin
    repeat
        IsCorrect := true;
        if (not(CheckPermission(Path))) then
        begin
            IsCorrect := false;
            Path := InputPathToFile();
        end;
    until IsCorrect;
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;
        Path := InputPathToFile();
        CheckOutputFile(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.