Program Lab_2_4;

uses
  System.SysUtils;

Type
    TMatrix = Array of Array of Integer;
    TOutputArray = Array of Integer;

Function ReadPath(): String;
Var
    Path: String;
    IsCorrect: Boolean;
Begin

    Repeat
        IsCorrect := True;
        Write('Введите адрес файла: ');
        Readln(Path);

        If (Not FileExists(Path)) Then
        Begin
            IsCorrect := False;
            Writeln('Файл не найден');
        End;
        If IsCorrect and (ExtractFileExt(Path) <>'.txt')  Then
        Begin
            IsCorrect := False;
            Writeln('Неверное расширение файла.');
        End;
    Until IsCorrect;
    Writeln('Файл был успешно найден.Начинается чтение...');
    ReadPath := Path;
End;

Procedure FoundNewFile(Var FIO: TextFile);
Var
    Path: String;
Begin
    Path := ReadPath();
    AssignFile(FIO, Path);
    Reset(FIO);
End;

Function ReadFromFOI(Var FIO: TextFile; Const MAX, MIN: Integer): Integer;
Var
    Num: Integer;
    IsCorrect: Boolean;
    Path: String;
Begin
    IsCorrect := True;
    Repeat
        Try
            Read(FIO, Num);
        Except
            Writeln('Неверные данные в файле.');
            IsCorrect := False;
            FoundNewFile(FIO);
        End;
        If IsCorrect and ((Num > MAX) or (Num < Min)) Then
        Begin
            Writeln('Неверный интервал значений.');
            IsCorrect := False;
            FoundNewFile(FIO);
        End;
    Until IsCorrect;
    ReadFromFOI := Num;
End;

Function FillMatrixFIO(Var FIO: TextFile): TMatrix;
Var
    Matrix: TMatrix;
    Size, I, J: Integer;
Begin
    Size := ReadFromFOI(FIO, 6, 2);
    SetLength(Matrix, Size, Size);
    Dec(Size);

    For I := 0 To Size Do
        For J := 0 To Size Do
            Matrix[I][J] := ReadFromFOI(FIO, 100, -100);
    FillMatrixFIO := Matrix;
End;

Function ReadInfoFIO(): TMatrix;
Var
    FIO: TextFile;
    Matrix: TMatrix;
Begin
    Try
        FoundNewFile(FIO);
        Matrix := FillMatrixFIO(FIO);
    Finally
        CloseFile(FIO);
    End;
    ReadInfoFIO := Matrix;
End;

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;

Procedure OutputInFile(Arr : Array of Integer);
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;
    Append(TFile);
    Writeln(TFile);
    Writeln(TFile, 'Адрес оседлой точки с точки зрения динамического массива: ', Arr[0], ',', Arr[1]);
    Writeln(TFile, 'Адрес оседлой точки с точки зрения  математики: ', (Arr[0] + 1), ',', (Arr[1] + 1));
    CloseFile(TFile);
    Writeln('Данные записаны в файл.');
    Readln;

End;

Procedure OutputChoice(Point : Array of Integer);
Var
    IsCorrect : Boolean;
    Num : Integer;
Begin
    Repeat
        IsCorrect := True;
        Writeln('Выберите, куда выводить ответ: 0, если в консоль; 1, если в файл');
        Try
            Readln(Num);
        Except
            IsCorrect := False;
        End;
        If ((Not IsCorrect) Or ((Num <> 0) And (Num <> 1))) Then
        Begin
            IsCorrect := False;
            Writeln('Неверный ввод данных. Введите 0 или 1');
        End;
    Until IsCorrect;

    If (Num = 0) Then
    Begin
         Writeln('Адрес оседлой точки с точки зрения динамического массива: ', Point[0], ',', Point[1] );
         Writeln('Адрес оседлой точки с точки зрения  математики: ', (Point[0] + 1), ',', (Point[1] + 1) );
         Readln;
    End
    Else
        OutputInFile(Point);

End;

Function HasSaddlePoint(Const Arr: TMatrix): TOutputArray;
Var
  MinInRow, MinInRowIndex, I, J, K: Integer;
  IsMaximum: Boolean;
  OutputArray: TOutputArray;
Begin
  SetLength(OutputArray, 0);
  For I := 0 To High(Arr) Do
  Begin
    MinInRow := MaxInt;
    IsMaximum := True;

    For J := 0 To High(Arr[I]) 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) Or Not (Arr[K][MinInRowIndex] = MinInRow)) Then
        IsMaximum := False;
    end;

    If IsMaximum Then
    Begin
      Writeln('Оседлая точка существует в позиции [', I+1, '][', MinInRowIndex+1, '].');
      SetLength(OutputArray, Length(OutputArray) + 1);

    End;
  End;

  If Length(OutputArray) = 0 Then
    Writeln('Точка не существует');
    Result := OutputArray;
    Readln;
end;


Function MatrixReadConsole(Size : Integer; Matrix : TMatrix) : TMatrix;
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;
                Write('Введите элемент a[', I+1,',', J+1,']:');
                Try
                    Readln(Matrix[I][J]);
                Except
                    IsCorrect := False;
                    Writeln('Неверный тип данных');
                End;
            Until IsCorrect;
        End;
    End;

    MatrixReadConsole := Matrix;
End;

Function FromConsole() : TMatrix;

Var
    Size, MaxSum : Integer;
    Matrix : TMatrix;

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

    FromConsole := Matrix;
End;

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

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 :=  ReadInfoFIO();

    SourceChoice := Matrix;
End;

Var
    IsCorrect : Boolean;
    Point : TOutputArray;
    Matrix : TMatrix;
Begin
    OutputEssence();
    Matrix := SourceChoice();
    Point := HasSaddlePoint(Matrix);
    OutputChoice(Point);
End.