Lab with file

program lab_24;
{$APPTYPE CONSOLE}
uses
    System.SysUtils;
Type
    TArrInt = Array of Integer;
Var
    ChoiceInput, ChoiceOutput: Integer;
    Arr1, Arr2, Answer: TArrInt;

Function InputInt(Min, Max: Integer): Integer;
Var
    IsCorrect: Boolean;
    Int: Integer;
Begin
    Repeat
        IsCorrect := True;
        Write('Введите число: ');
        Try
            Readln(Int);
        Except
            IsCorrect := False;
            Writeln('Вы ввели некорректные данные. Попробуйте снова.');
        End;
        If IsCorrect And ((Int > Max ) Or (Int < Min)) Then
        Begin
            IsCorrect := False;
            Writeln('Введено значение не входящее в диапазон допустимых значений');
        End;
    Until IsCorrect;
    InputInt := Int;
End;

Procedure InputArrayFromConsole(Var Arr: TArrInt);
Var
    IsCorrect: Boolean;
    I, K, LengthArr: Integer;
Const
    MIN_ARR_LENGTH = 1;
    MAX_ARR_LENGTH = 10;
    MAX_A_VALUE = 100;
    MIN_A_VALUE = -100;
Begin
    Writeln('Введите все элементы массива : ');
    I := 0;
    LengthArr := InputInt(MIN_ARR_LENGTH, MIN_ARR_LENGTH);
    SetLength(Arr, LengthArr);
    While I < Length(Arr) Do
    Begin
        Writeln('Введите элемент массива №', I + 1, ': ');
        Arr[I] := InputInt(MIN_A_VALUE, MAX_A_VALUE);
        K := 0;
        While IsCorrect And (K < I) Do
        Begin
            If Arr[I] = Arr[K] Then
                Writeln('Числа в последовательностях не должны повторяться!');
                IsCorrect := False;
                Dec(I);
        End;
        Inc(I);
    End;
End;

Function CheckFile(Path: String): Boolean;
Var
    IsFileCorrect: Boolean;
    InputFile: TextFile;
    Length, I, J, K: Integer;
    CheckArr: Array of Integer;
Const
    MIN_ARR_LENGTH = 1;
    MAX_ARR_LENGTH = 10;
    MAX_A_VALUE = 100;
    MIN_A_VALUE = -100;
Begin
    IsFileCorrect := True;

    If FileExists(Path) Then
    Begin
        for I := 0 to 2 do
        Begin
            AssignFile(InputFile, Path);
            Reset(InputFile);
            Try
                Read(InputFile, Length);
            Except
                Writeln('Данные в файле в неправильном формате');
                IsFileCorrect := False;
            End;
            If IsFileCorrect And (Length < MIN_ARR_LENGTH) Or
                                 (Length > MAX_ARR_LENGTH) Then
            Begin
                Writeln('Данные в файле выходят за возможные пределы');
                IsFileCorrect := False;
            End;
            SetLength(CheckArr, Length);
            J := 0;
            While (J < Length) And IsFileCorrect Do
            Begin
                Try
                Read(InputFile, CheckArr[J]);
                Except
                    Writeln('Данные в файле в неправильном формате');
                    IsFileCorrect := False;
                End;
                If (CheckArr[J] < MIN_A_VALUE) Or (CheckArr[J] > MAX_A_VALUE) Then
                Begin
                    Write('Данные в файле выходят за возможные пределы');
                    IsFileCorrect := False;
                End;
                K := 0;
                While IsFileCorrect And (K < J) Do
                Begin
                    If (CheckArr[K] = CheckArr[J]) Then
                    Begin
                        Writeln('Числа в последовательностях не должны повторяться!
                                 Внесите изменения в файл и повторите попытку.');
                        IsFileCorrect := True;
                    End;
                    Inc(K);
                End;
                Inc(J);
            End;
            If IsFileCorrect and Not(EoF(InputFile)) Then
            Begin
                Writeln('Данные в файле выходят за возможные пределы');
                IsFileCorrect := False;
            End;
        End;
    End
    Else
    Begin
        Writeln('Файла по данному пути не существует');
        IsFileCorrect := False;
    End;
    CloseFile(InputFile);
    CheckFile := IsFileCorrect;
End;

Procedure InputArraysFromFile(Path: String; Var Arr1, Arr2: TArrInt);
Var
    InputFile: TextFile;
    LengthArr1, LengthArr2, I: Integer;
Begin
    AssignFile(InputFile, Path);
    Reset(InputFile);
    Read(InputFile, LengthArr1);
    SetLength(Arr1, LengthArr1);
    For I := 0 To High(Arr1) Do
        Read(InputFile, Arr1[I]);
    Read(InputFile, LengthArr2);
    SetLength(Arr2, LengthArr2);
    For I := 0 To High(Arr2) Do
        Read(InputFile, Arr2[I]);
    CloseFile(InputFile);
End;
Procedure InputArrays(Choice: Integer; Var Arr1, Arr2: TArrInt);
Var
    IsFileCorrect: Boolean;
    Path: String;
    InputFile: TextFile;
Begin
    If Choice = 1 Then
    Begin
        InputArrayFromConsole(Arr1);
        InputArrayFromConsole(Arr2);
    End
    Else
    Begin
        Repeat
            Writeln('Введите путь к файлу: ');
            Readln(Path);
            IsFileCorrect := CheckFile(Path);
        Until IsFileCorrect;
        InputArraysFromFile(Path, Arr1, Arr2);
    End;
End;

Function MakeIntegration(Var Arr1, Arr2: TArrInt): TArrInt;
Var
    LengthAnswer, I, J: Integer;
    Answer : TArrInt;
    IsUnique: Boolean;
Begin
    LengthAnswer := Length(Arr1) + Length(Arr2);
    SetLength(Answer, LengthAnswer);
    For I := 0 To High(Answer) Do
        Answer[I] := 101;
    For I := 0 To High(Arr1) Do
        Answer[I] := Arr1[I];
    For I := 0 To High(Arr2) Do
    Begin
        IsUnique := True;
        For J := 0 To High(Arr2) Do
        Begin
            If Arr2[J] = Answer[J] Then
                IsUnique := False;
        End;
        If IsUnique Then
            Answer[I + Length(Arr1)] := Arr2[I];
    End;
    MakeIntegration := Answer;
End;

Procedure OutputAnswer(Choice: Integer; Var Answer: TArrInt);
Var
    Path: String;
    OutputFile: TextFile;
    I: Integer;
Const
    MAX_ARR_VALUE = 100;
Begin
    If Choice = 1 Then
    Begin
        Writeln('Результат');
        For I := 0 To High(Answer) Do
        Begin
            If Answer[I] < MAX_ARR_VALUE Then
            Write(Answer[I],' ');
        End;
    End
    Else
    Begin
        Writeln('Введите путь к файлу для вывода.
                 Если файл отсутствует то он будет создан автоматически');
        Readln(Path);
        AssignFile(OutputFile, Path);
        Rewrite(OutputFile);
        For I := 0 To High(Answer) Do
        Begin
            If Answer[I] < MAX_ARR_VALUE Then
            Write(OutputFile , Answer[I],' ');
        End;
        CloseFile(OutputFile);
    End;
End;

Begin
    Write('Программа находит объединение двух массивов ', #10,
        'Диапазон значений для ввода длины массива  - от 1 до 10.', #10,
        'Диапазон значений для ввода значений массива - от -100 до 100. ', #10);
    Writeln('Выберите вариант ввода' , #10 , '1. Через консоль', #10, '2. Из файла');
    ChoiceInput := InputInt(1,2);
    InputArrays(ChoiceInput, Arr1, Arr2);
    Writeln('Выберите вариант вывода' , #10 , '1. Через консоль', #10, '2. В файл');
    ChoiceOutput := InputInt(1,2);
    Answer := MakeIntegration(Arr1, Arr2);
    OutputAnswer(ChoiceOutput, Answer);
    Readln;
End.