Program Lab_2_4;

uses
  System.SysUtils;

Type
    TArray = Array of Array of Integer;
    TOutputArray = Array of Integer;

Function ErrorInput(I, J : Integer) : Integer;
Var
    Number : Integer;
    IsCorrect : Boolean;
Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите ', I+1, ' ' , J+1, ' элемент массива: ');
        Try
            Readln(Number);
        Except
            IsCorrect := False;
            Writeln('Неверный тип данных');
        End;
    Until IsCorrect;

    ErrorInput := Number;
End;

Procedure OutputEssence();
Begin
     Writeln('Суть задания: найти седловую точку в матрице, т.е элемент, который является наименьшим в своей строке, но наибольшем в столбце.');
End;

Function SizeConsole() : Integer;
Var
    IsCorrect : Boolean;
    Size : Integer;
Begin
  Repeat
        IsCorrect := True;
        Writeln('Введите размер матрицы: ');
        Try
            Readln(Size);
        Except
            IsCorrect := False;
            Writeln('Неверный тип данных');
        End;
        If (Size < 1) Then
        Begin
            IsCorrect := False;
            Writeln('Неверный тип данных');
        End;
    Until IsCorrect;

    SizeConsole := Size;

End;

Function PathChoice() : String;
Var
    TFile : TextFile;
    Path : String;
    IsCorrect : Boolean;

Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите путь файла: ');
        Try
            Readln(Path);
            AssignFile(TFile, Path);
            Reset(TFile);
        Except
            IsCorrect := False;
            Writeln('Неверный путь файла!');
        End;
    Until IsCorrect;
    Writeln('Файл успешно открыт!');
    PathChoice := Path;
    CloseFile(TFile);
End;

Function SizeFile(Path : String; var TFile : TextFile) : Integer;
Var
    Size : Integer;
    Line : String;
    IsCorrect : Boolean;

Begin
    AssignFile(TFile, Path);
    Reset(TFile);
    IsCorrect := True;
    Writeln('Запись размера матрицы...');
    Try
        Readln(TFile, Size);
    Except
        IsCorrect := False;
    End;
    If ((Size < 1) Or (IsCorrect = False)) Then
    Begin
        Writeln('Ошибка! Неверный ввод размера! Введите данные с клавиатуры.');
        Size := SizeConsole();
    End;

    Writeln('Размер матрицы: ', Size);
    CloseFile(TFile);
    SizeFile := Size;

End;

Function MatrixReadFile(Path : String; Size : Integer; var TFile : TextFile; Matrix : TArray) : TArray;
Var
    I, J, Correct : Integer;
    Line : String;
    IsCorrect : Boolean;

Begin
    AssignFile(TFile, Path);
    Reset(TFile);
    Dec(Size);
    IsCorrect := True;
    Readln(TFile, Line);

    Writeln('Запись матрицы...');
    For I := 0 To (Size) Do
    Begin
        For J := 0 To (Size) Do
        Begin
            Try
                Read(TFile, Matrix[I][J])
            Except
                IsCorrect := False;
                Writeln(' Неверный ввод данных! Введите элемент матрицы с размером ', I+1, ' ', J+1, ' с клавиатуры.');
                Matrix[I][J] := ErrorInput(I, J);
            End;
        End;
    End;
    CloseFile(TFile);

    Writeln('Вывод матрицы: ');
    For I := 0 To Size Do
    Begin
        For J := 0 To Size Do
            Write(Matrix[I][J], ' ');
        Writeln;
    End;

    MatrixReadFile := Matrix;

End;

Function MatrixCount(const Arr : TArray) : TOutputArray;

Var
    MinInRow, MinInRowIndex, I, J, K : Integer;
    IsMaximum, IsExsist : Boolean;
    OutputArray : TOutputArray;

Begin

    IsExsist := False;
    For I := 0 To High(Arr) Do
    Begin
        MinInRow := 999999999;
        IsMaximum := True;

        For J := 0 To High(Arr) Do
        Begin
            If (Arr[I][J] < MinInRow) Then
            Begin
                MinInRow := Arr[I][J];
                MinInRowIndex := J;
            End;

        End;

        For K := 0 To High(Arr) Do
        Begin
            If Not (Arr[K][MinInRowIndex] <= MinInRow) Then
            IsMaximum := False;
        End;

        If IsMaximum Then
        Begin
            Writeln('Оседлая точка существует.');
            IsExsist := True;
            SetLength(OutputArray, 2);
            OutputArray[0] := I;
            OutputArray[1] := MinInRowIndex;
        End;

    End;

    If Not IsExsist Then
        Writeln('Точка не существует');


    MatrixCount := OutputArray;

End;

Procedure Output(Arr : TOutputArray);
Var
    TFile : TextFile;
    Path : String;
    IsCorrect : Boolean;
Begin
    Writeln('Адрес оседлой точки с точки зрения динамического массива: ', Arr[0], ',', Arr[1] );
    Writeln('Адрес оседлой точки с точки зрения  математики: ', (Arr[0] + 1), ',', (Arr[1] + 1) );
    Repeat
        IsCorrect := True;
        Writeln('Введите путь файла для вывода: ');
        Try
            Readln(Path);
            AssignFile(TFile, Path);
            Reset(TFile);
        Except
            IsCorrect := False;
            Writeln('Неверный путь файла!');
        End;
    Until IsCorrect;
    Append(TFile);
    Writeln(TFile);
    Writeln(TFile, 'Адрес оседлой точки с точки зрения динамического массива: ', Arr[0], ',', Arr[1]);
    Writeln(TFile, 'Адрес оседлой точки с точки зрения  математики: ', (Arr[0] + 1), ',', (Arr[1] + 1));
    CloseFile(TFile);
    Writeln('Данные записаны в файл.');
    Readln;

End;

Function FromFile() : TArray;

Var
    Path : String;
    Size : Integer;
    TFile : TextFile;
    Matrix : TArray;

Begin
    Writeln('При записи данных из файла, учтите, что на первой строке в файле записан размер, а далее с новой строки сама матрица.');
    Path := PathChoice();
    Size := SizeFile(Path, TFile);
    SetLength(Matrix, Size, Size);
    Matrix := MatrixReadFile(Path, Size, TFile, Matrix);

    FromFile := Matrix;
End;

Function MatrixReadConsole(Size : Integer; Matrix : TArray) : TArray;
Var
    IsCorrect : Boolean;
    I, J : Integer;
Begin
    Dec(Size);

    For I := 0 To Size Do
    Begin
        For J := 0 To Size Do
        Begin
            Repeat
                IsCorrect := True;
                Writeln('Введите элемент с индексом ', I+1,',', J+1);
                Try
                    Readln(Matrix[I][J]);
                Except
                    IsCorrect := False;
                    Writeln('Неверный тип данных');
                End;
            Until IsCorrect;
            Write(Matrix[I][J], ' ');
        End;
        Writeln;
    End;

    MatrixReadConsole := Matrix;
End;

Function FromConsole() : TArray;

Var
    Size, MaxSum : Integer;
    Matrix : TArray;

Begin
    Size := SizeConsole();
    SetLength(Matrix, Size, Size);
    Matrix := MatrixReadConsole(Size, Matrix);

    FromConsole := Matrix;
End;

Function SourceChoice() : TArray;
Var
    ChoiceNumber : Integer;
    IsCorrect : Boolean;
    Matrix : TArray;

Begin
    Writeln('Выберите, откуда будут вводиться данные:');
    Repeat
        IsCorrect := True;
        Writeln('Введите 0, если с консоли; введите 1, если с файла.');
        Try
            Readln(ChoiceNumber);
        Except
            IsCorrect := False;
        End;
        If ((IsCorrect = False) Or ((ChoiceNumber <> 1) And (ChoiceNumber <> 0))) Then
        Begin
            Writeln('Неверный ввод данных!');
            IsCorrect := False;
        End;
    Until IsCorrect;
    If (ChoiceNumber = 0) Then
        Matrix := FromConsole()
    Else
        Matrix := FromFile();

    SourceChoice := Matrix;
End;

Var
    IsCorrect : Boolean;
    Point : TOutputArray;
    Matrix : TArray;

Begin
    OutputEssence();
    Matrix := SourceChoice();
    Point := MatrixCount(Matrix);
    Output(Point);
End.