Program Lab_matrix;

uses
  System.SysUtils;

Type
    TMatrix = Array Of Array Of Integer;

Procedure OutputTask();
Begin
    Writeln('Данная программа рассчитывает наибольшее отрицательное число среди заданной квадратной матрицы.');
End;

Function ChooseInput() : Boolean;
Var
    IsCorrect : Boolean;
    Num : Integer;
Begin
    Repeat
        Writeln('Выберите откуда вводить данные: 0, если из консоли, 1 если из файла:');
        IsCorrect := True;
        Try
            Readln(Num);
        Except
            IsCorrect := False;
        End;
        If (Not IsCorrect) Or ((Num <> 0) And (Num <> 1)) Then
        Begin
            IsCorrect := False;
            Writeln('Ошибка ввода! Повторите попытку.');
        End;
    Until IsCorrect;

    ChooseInput := (Num = 1);
End;

Function ChoosePath() : String;
Var
    Path : String;
    IsCorrect : Boolean;
    InputFile : TextFile;
Begin
    Begin
        Repeat
            Writeln('Введите путь к файлу для ввода информации: ');
            IsCorrect := True;
            Readln(Path);
            Try
                AssignFile(InputFile, Path);
                Reset(InputFile);
            Except
                IsCorrect := False;
            End;
            If (Not IsCorrect) Or (Length(Path) < 5) Then
            Begin
                  IsCorrect := False;
                  Writeln('Ошибка ввода! Повторите попытку.');
            End
            Else
            Begin
                If ((Path[High(Path)] <> 't') And (Path[High(Path) - 1] <> 'x') And (Path[High(Path) - 2] <> 't') And (Path[High(Path) - 3] <> '.')) Then
                Begin
                    IsCorrect := False;
                    Writeln('Ошибка ввода! Повторите попытку.');
                End;
            End;
        Until IsCorrect;
    End;

    CloseFile(InputFile);

    ChoosePath := Path;
End;

Function InputSizeFromConsole() : Integer;
Var
    IsCorrect : Boolean;
    Size : Integer;
Begin
    Repeat
        IsCorrect := True;
        Writeln('Введите размер матрицы(от 2 до 100):');
        Try
            Readln(Size);
        Except
            IsCorrect := False;
        End;
        If (Not IsCorrect) Or (Size < 2) Or (Size > 100) Then
        Begin
            IsCorrect := False;
            Writeln('Ошибка ввода! Повторите попытку.');
        End;
    Until IsCorrect;

    InputSizeFromConsole := Size;
End;

Function InputSizeFromFile(Path : String) : Integer;
Var
    Size : Integer;
    IsCorrect : Boolean;
    InputFile : TextFile;
Begin
    AssignFile(InputFile, Path);
    Reset(InputFile);
    IsCorrect := True;
    Writeln('Запись размера...');
    Try
        Readln(InputFile, Size)
    Except
        IsCorrect := False;
    End;
    If (Not IsCorrect) Or (Size < 2) Or (Size > 100) Then
    Begin
        IsCorrect := False;
        Writeln('Ошибка ввода! Введите размер с клавиатуры.');
        Size := InputSizeFromConsole();
    End;
    CloseFile(InputFile);

    InputSizeFromFile := Size;
End;

Function ExceptionRead(I, J : Integer) : Integer;
Var
    IsCorrect : Boolean;
    Num : Integer;
Begin
    Repeat
        Writeln('Введите [', I+1, ' , ', J+1, '] элемент матрицы:');
        IsCorrect := True;
        Try
            Readln(Num);
        Except
            IsCorrect := False;
            Writeln('Ошибка ввода! Повторите попытку.');
        End;
    Until IsCorrect;

    ExceptionRead := Num;
End;

Function FillMatrixFromFile(Path : String; Matrix : TMatrix) : TMatrix;
Var
    I, J : Integer;
    InputFile : TextFile;
Begin
    Writeln('Запись матрицы...');
    AssignFile(InputFile, Path);
    Reset(InputFile);
    Readln(InputFile);
    For I := 0 To High(Matrix) Do
    Begin
        For J := 0 To High(Matrix) Do
        Begin
            Try
                Read(InputFile, Matrix[I, J]);
            Except
                Writeln('Ошибка ввода! Введите [', I+1, ' , ', J+1, '] элемент матрицы с клавиатуры.');
                Matrix[I, J] := ExceptionRead(I, J);
            End;
        End;
        Readln(InputFile);
    End;

    CloseFile(InputFile);

    FillMatrixFromFIle := Matrix;
End;

Function InputMatrixFromFile() : TMatrix;
Var
    Path : String;
    Matrix : TMatrix;
    Size : Integer;
Begin
	Writeln('При записи из файла учтите, что на 1 строке должен быть записан размер матрицы, а далее с новой строки сама матрица(через пробел');
    Path := ChoosePath();
    Size := InputSizeFromFile(Path);
    SetLength(Matrix, Size, Size);
    Matrix := FillMatrixFromFile(Path, Matrix);

    InputMatrixFromFile := Matrix;
End;

Function FillMatrixFromConsole(Matrix : TMatrix) : TMatrix;
Var
    I, J : Integer;
    IsCorrect : Boolean;
Begin
    For I := 0 To High(Matrix) Do
    Begin
        For J := 0 To High(Matrix) Do
        Begin
            Repeat
                Writeln('Введите [', I+1, ' , ', J+1, '] элемент матрицы:');
                IsCorrect := True;
                Try
                    Readln(Matrix[I, J]);
                Except
                    IsCorrect := False;
                    Writeln('Ошибка ввода! Повторите попытку.');
                End;
            Until IsCorrect;
        End;
    End;

    FillMatrixFromConsole := Matrix;
End;

Function InputMatrixFromConsole() : TMatrix;
Var
    Size : Integer;
    Matrix : TMatrix;
Begin
    Size := InputSizeFromConsole();
    SetLength(Matrix, Size, Size);
    Matrix := FillMatrixFromConsole(Matrix);

    InputMatrixFromConsole := Matrix;
End;

Function InputMatrix(IsFromFile : Boolean) : TMatrix;
Var
    Matrix : TMatrix;
Begin
    If IsFromFile Then
        Matrix := InputMatrixFromFile()
    Else
        Matrix := InputMatrixFromConsole();

    InputMatrix := Matrix;
End;

Function FindLargestNegativeNumber(Matrix : TMatrix) : Integer;
Var
    I, J, Num : Integer;
    IsThereNegative : Boolean;
Begin
    IsThereNegative := False;
    For I := 0 To High(Matrix) Do
    Begin
        For J := 0 To High(Matrix) Do
        Begin
            If Matrix[I, J] < 0 Then
            Begin
                IsThereNegative := True;
                Num := Matrix[I, J];
            End;
        End;
    End;

    If IsThereNegative Then
    Begin
        For I := 0 To High(Matrix) Do
        Begin
            For J := 0 To High(Matrix) Do
            Begin
                If ((Matrix[I, J] > Num) And (Matrix[I, J] < 0 )) Then
                    Num := Matrix[I, J];
            End;
        End;
    End
    Else
    Begin
        Num := 0;
    End;

    FindLargestNegativeNumber := Num;
End;

Function ChoosePathForOutput() : String;
Var
    Path : String;
    IsCorrect : Boolean;
    OutputFile : TextFile;
Begin
    Begin
        Repeat
            Writeln('Введите путь к файлу для вывода информации: ');
            IsCorrect := True;
            Readln(Path);
            Try
                AssignFile(OutputFile, Path);
                Reset(OutputFile);
            Except
                IsCorrect := False;
            End;
            If (Not IsCorrect) Or (Length(Path) < 5) Then
            Begin
                  IsCorrect := False;
                  Writeln('Ошибка ввода! Повторите попытку.');
            End
            Else
            Begin
                If ((Path[High(Path)] <> 't') And (Path[High(Path) - 1] <> 'x') And (Path[High(Path) - 2] <> 't') And (Path[High(Path) - 3] <> '.')) Then
                Begin
                    IsCorrect := False;
                    Writeln('Ошибка ввода! Повторите попытку.');
                End;
            End;
        Until IsCorrect;
    End;

    CloseFile(OutputFile);

    ChoosePathForOutput := Path;
End;

Procedure OutputInFile(Num : Integer);
Var
    Path : String;
    OutputFile : TextFile;
Begin
    Path := ChoosePathForOutput();
    AssignFile(OutputFile, Path);
    Append(OutputFile);
    If (Num = 0) Then
        Writeln(OutputFile, #13#10'Матрица не имеет отрицательные элементы.')
    Else
        Writeln(OutputFile, #13#10'Наибольший отрицательный элемент матрицы: ', Num);

    Writeln('Данные успешно записаны в файл!');
End;

Procedure OutputAnswer(Num : Integer);
Begin
    If (Num = 0) Then
        Writeln('Матрица не имеет отрицательные элементы.')
    Else
        Writeln('Наибольший отрицательный элемент матрицы: ', Num);

    OutputInFile(Num);
End;

Procedure OutputMatrix(Matrix : TMatrix);
Var
    I, J : Integer;
Begin
    Writeln('Исходная матрица: ');
    For I := 0 To High(Matrix) Do
    Begin
        For J := 0 To High(Matrix) Do
        Begin
              Write(Matrix[I, J], ' ');
        End;
        Writeln;
    End;

End;

Var
    IsFromFile : Boolean;
    Size , LargestNegativeNumber : Integer;
    Matrix : TMatrix;
Begin
    OutputTask();
    IsFromFile := ChooseInput();
    Matrix := InputMatrix(IsFromFile);
    OutputMatrix(Matrix);
    LargestNegativeNumber := FindLargestNegativeNumber(Matrix);
    OutputAnswer(LargestNegativeNumber);

    Readln;
End.