Lab.3.3

Program Lab_3_3;

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

Uses
    System.SysUtils;

Type
    TArr = Array Of Integer;

Const
    MAX_SIZE = 100;
    MIN_SIZE = 2;
    MAX_ELEMENT = 2147483647;
    MIN_ELEMENT = -2147483648;

Procedure WriteTask();
Begin
    Writeln('Данная программа реализует сортировку простыми вставками');
End;

Function TakeSizeOfArrFromConsole(): Integer;
Var
    IsCorrect: Boolean;
    Size: Integer;
Begin
    Repeat
        IsCorrect := True;
        Write('Введите длину сортируемого массива: ');
        Try
            Readln(Size);
        Except
            IsCorrect := False;
            Writeln('Некорректный ввод. Повторите попытку...')
        End;
        If (IsCorrect) And ((Size < MIN_SIZE) Or (Size > MAX_SIZE)) Then
        Begin
            IsCorrect := False;
            Writeln('Длина массива должна быть в диапазоне от 2 до 100.');
        End;
    Until (IsCorrect);
    TakeSizeOfArrFromConsole := Size;
End;

Function TakePathToFile(): String;
Var
    Path: String;
    IsCorrect: Boolean;
    F: TextFile;
Begin
    Repeat
        IsCorrect := True;
        Write('Введите путь к файлу: ');
        Readln(Path);
        AssignFile(F, Path);
        If (Not(FileExists(Path))) Then
        Begin
            IsCorrect := False;
            Writeln('Не удалось найти файл по заданному пути. Повторите попытку...');
        End;
    Until (IsCorrect);
    TakePathToFile := Path;
End;

Procedure WriteArr(Arr: TArr);
Var
    I: Integer;
Begin
    For I := 0 To High(Arr) Do
        Write(Arr[I], ' ');
    Writeln;
End;

Function TakeArrFromConsole(Size: Integer): TArr;
Var
    I: Integer;
    Arr: TArr;
    IsCorrect: Boolean;
Begin
    SetLength(Arr, Size);
    For I := 0 To High(Arr) Do
    Begin
        Repeat
            IsCorrect := True;
            Write('Введите элемент массива №', (I + 1), ': ');
            Try
                Readln(Arr[I]);
            Except
                Writeln('Элемент введён некорректно. Повторите попытку...');
                IsCorrect := False;
            End;
            If (IsCorrect) And ((Arr[I] < MIN_ELEMENT) Or (Arr[I] > MAX_ELEMENT)) Then
            Begin
                IsCorrect := False;
                Writeln('Длина элемента массива должна быть в диапазоне от ', MIN_ELEMENT, ' до ', MAX_ELEMENT);
            End;
        Until (IsCorrect);
    End;
    TakeArrFromConsole := Arr;
End;

Function TakeArrFromFile(): TArr;
Var
    Arr: TArr;
    I, Size: Integer;
    IsCorrect: Boolean;
    F: TextFile;
    Path: String;
Begin
    Write('Требуется файл для получения массива. ');
    Path := TakePathToFile();
    Repeat
        IsCorrect := True;
        AssignFile(F, Path);
        I := 0;
        Try
            Reset(F);
            Try
                Readln(F, Size);
                SetLength(Arr, Size);
                While (IsCorrect) And (I < Size) Do
                Begin
                    Read(F, Arr[I]);
                    If (Arr[I] < MIN_ELEMENT) Or (Arr[I] > MAX_ELEMENT) Then
                    Begin
                        IsCorrect := False;
                        Write('Длина элемента массива должна быть в диапазоне от ', MIN_ELEMENT, ' до ', MAX_ELEMENT, '. ');
                    End;
                    Inc(I);
                End;
            Finally
                CloseFile(F);
            End;
            If (IsCorrect) And ((Size > MAX_SIZE) Or (Size < MIN_SIZE)) Then
            Begin
                Write('Размер массива выходит за границы допустимого диапазона! ');
                IsCorrect := False;
            End;
        Except
            IsCorrect := False;
            Write('Произошла ошибка при чтении файла. ');
        End;
        If Not(IsCorrect) Then
        Begin
            Writeln('Повторите попытку...');
            Path := TakePathToFile();
        End;
    Until (IsCorrect);
    TakeArrFromFile := Arr;
End;

Function ChooseInputOutputMethod(): Integer;
Var
    IsCorrect: Boolean;
    Choice: Integer;
Begin
    Repeat
        IsCorrect := True;
        Try
            Readln(Choice);
        Except
            Writeln ('Число введено некорректно. Повторите попытку...');
            IsCorrect := False;
        End;
        If (IsCorrect) And (Choice <> 1) And (Choice <> 2) Then
        Begin
            Writeln ('Введите либо 1, либо 2. Ваш выбор: ');
            IsCorrect := False;
        End;
    Until (IsCorrect);
    ChooseInputOutputMethod := Choice;
End;

Function GetArrForSort(): TArr;
Var
    Arr: TArr;
    Choice, Size: Integer;
Begin
    Write('Выберите способ ввода данных (1 - через консоль, 2 - с помощью файлов): ');
    Choice := ChooseInputOutputMethod();
    If (Choice = 1) Then
    Begin
        Size := TakeSizeOfArrFromConsole();
        Arr := TakeArrFromConsole(Size);
    End
    Else
        Arr := TakeArrFromFile();
    Write('Полученный массив: ');
    WriteArr(Arr);
    GetArrForSort := Arr;
End;

Procedure Sort(Var Arr: TArr);
Var
    I, J, X: Integer;
Begin
    For I := 1 To High(Arr) Do
    Begin
        X := Arr[I];
        J := I;
        While (J > 0) And (Arr[J - 1] > X) Do
        Begin
            Arr[J] := Arr[J - 1];
            Dec(J);
        End;
        Arr[J] := X;
        WriteArr(Arr);
    End;
End;

Procedure OutputSortedArrInFile(Arr: TArr);
Var
    IsCorrect: Boolean;
    F: TextFile;
    Path: String;
    I: Integer;
Begin
    Write('Требуется файл для записи отсортированного массива. ');
    Path := TakePathToFile();
    Repeat
        IsCorrect := True;
        AssignFile(F, Path);
        Try
            Rewrite(F);
            Try
                Write(F, 'Полученный массив: ');
                For I := 0 To High(Arr) Do
                Begin
                    Write(F, Arr[I]);
                    Write(F, ' ');
                End;
            Finally
                CloseFile(F);
            End;
        Except
            IsCorrect := False;
            Write('Произошла ошибка записи в файл. ');
            Write('Повторите попытку... ');
            Path := TakePathToFile();
        End;
    Until (IsCorrect);
    Writeln('Ответ записан в файл!');
End;

Procedure OutputSortedArr(Arr: TArr);
Var
    Choice: Integer;
Begin
    Write('Выберите способ вывода полученной строки(1 - с помощью консоли, 2 - с помощью файлов): ');
    Choice := ChooseInputOutputMethod();
    If (Choice = 1) Then
    Begin
        Write('Полученный массив: ');
        WriteArr(Arr);
    End
    Else
        OutputSortedArrInFile(Arr);
End;

Var
    Arr: TArr;
Begin
    WriteTask();
    Arr := GetArrForSort();
    Writeln('Процесс сортировки:');
    Sort(Arr);
    OutputSortedArr(Arr);
    Readln;
End.