program lab3_3;

uses
    System.SysUtils;

type
    TArr = array of Integer;



function IsNotCorrectRange(Mem: Integer; Min: Integer; Max: Integer): Boolean;
begin
    IsNotCorrectRange := ((Mem < Min) or (Mem > Max))
end;


function ChooseFileName(FileN1: String; FileN2: String; FileN3: String): String;
var
    Answer: Integer;
    IsCorrectInt: Boolean;
    FileName: String;
begin
    IsCorrectInt := False;
    repeat
         WriteLn('Select the file you want to use: ');// + #13#10 + '1) ', + fileN1 + #13#10 + '2) ' + fileN2 + #13#10 + '3) ' + fileN3);
        try
            ReadLn(Answer);
            if (Answer = 1) then
            begin
                FileName := FileN1;
                IsCorrectInt := True;
            end;

            if (Answer = 2) then
            begin
                FileName := FileN2;
                IsCorrectInt := True;
            end;

            if (Answer = 1) then
            begin
                FileName := FileN1;
                IsCorrectInt := True;
            end;
        except
            WriteLn('ук1')
        end;
    until (IsCorrectInt);
    ChooseFileName := FileName;
end;

procedure DoubleInsertionSorting(OriginaleArr: TArr);
var
    N, I, J, Test, Left, Right: Integer;
    SortArr: TArr; // вспомогательный массив для вывода
begin
       Writeln('or');
    begin
        N := Length(OriginaleArr);
        Left := N - 1;
        Right := N - 1;
        SetLength(SortArr, 2 * N - 1);
        SortArr[N] := OriginaleArr[1];
        // вставляем первый элемент в середину вспомогательного массива

        for I := 2 to N do
        begin
            Test := OriginaleArr[I];
            if Test > OriginaleArr[1] - 1 then
            begin
                Inc(Right);
                J := Right;
                while Test < SortArr[J - 1] do
                begin

                    SortArr[J] := SortArr[J - 1];
                    Dec(J);
                end;
                SortArr[J] := Test;
            end
            else
            begin
                Dec(Left);
                J := Left;
                while Test > SortArr[J + 1] do
                begin
                    SortArr[J] := SortArr[J + 1];
                    Inc(J);
                end;
                OriginaleArr[J] := Test;
            end;
        end;
        for J := 1 to N do
        begin
            OriginaleArr[J] := SortArr[J + Left - 1];
            WriteLn(OriginaleArr[J]);
        end;
        ReadLn;
    end;
end;

function TakeArrayFromFile(FileName: String; const Min_Arr: Integer;
  const Max_Arr: Integer; const Min: Integer; const Max: Integer): TArr;
var
    InputFile: TextFile;
    ArrSize, I, Counter: Integer;
    FileArr: TArr;
begin
    Counter := 0;
    AssignFile(InputFile, FileName);
    WriteLn('');
    try
        Reset(InputFile);
        WriteLn('');
        Read(InputFile, ArrSize);
        if (IsNotCorrectRange(ArrSize, Min_Arr, Max_Arr)) then
            Inc(Counter);
        WriteLn(ArrSize);
        SetLength(FileArr, ArrSize);
        for I := 0 to ArrSize do
        begin
            Read(InputFile, FileArr[I]);
            Write(FileArr[I], ' ');
        end;
        for I := 0 to ArrSize do
        begin
            if (IsNotCorrectRange(FileArr[I], 0, 100)) then
                Inc(Counter);
        end;
        if (Counter > 0) then
            FileArr := nil;

    finally
        Close(InputFile);
    end;
    TakeArrayFromFile := FileArr;
end;


function TakeCorrectInt(const Min: Integer; const Max: Integer): Integer;
var
    IsCorrectInt: Boolean;
    Mem: Integer;
begin
    Mem := 0;
    IsCorrectInt := True;
    repeat
        try
            ReadLn(Mem);
            if (IsNotCorrectRange(Mem, Min, Max)) then
            begin
                IsCorrectInt := False;
                WriteLn('Not correct variable range. It must be integer from ', Min, ' to ', Max, '. Try again.');
            end;
        except
            IsCorrectInt := False;
            WriteLn('Not correct input type.');
        end;
    until (IsCorrectInt);
    TakeCorrectInt := Mem;
end;


function TakeArray(): TArr;
var
    FileName1, FileName2, FileName3, FileName: String;
    IsCorrectInput, IsCorrectInt: Boolean;
    Answer, ArrSize, I: Integer;
    OriginalArr: TArr;
begin
    IsCorrectInput := True;
    repeat
        try
            WriteLn('If you want to use default file, enter "0".');
            WriteLn('If you want to use the console input, enter "1".');
            ReadLn(Answer);
            if (Answer = 0) then
            begin
                FileName1 := 'lab3_3input1.txt';
                FileName2 := 'lab3_3input2.txt';
                FileName3 := 'lab3_3input3.txt';
                FileName := ChooseFileName(FileName1, FileName2, FileName3);
                if FileExists(FileName) then
                begin
                    WriteLn('Using ', FileName, ' file to get value.');
                    OriginalArr := TakeArrayFromFile(FileName, 0, 20, 0, 100);
                end
                else
                    WriteLn('File ', FileName, ' does not exists.');
            end;
            if (Answer = 1) then
            begin
                IsCorrectInt := True;
                WriteLn('Enter array size less than 20.');
                repeat
                    try
                        ArrSize := TakeCorrectInt(0, 20);
                        WriteLn('Enter ', ArrSize, ' members of array.');
                        SetLength(OriginalArr, ArrSize);
                        for I := 0 to ArrSize do
                            OriginalArr[I] := TakeCorrectInt(0, 100);
                    except
                        IsCorrectInt := False;
                        WriteLn('Not right input. Try again.');

                    end;
                until (IsCorrectInt);
            end;
        except
            WriteLn('Not correct input. It must be a number. Try again.');
            IsCorrectInput := False;
        end;
    until IsCorrectInput;
    TakeArray := OriginalArr;
end;

//procedure WriteMagicSquareToFile(FileName: String; Quantity: Integer);
//var
//    OutputFile: TextFile;
//    IsNotCorrectOpiration: Boolean;
//    I, J: Integer;
//begin
//    Assign(OutputFile, FileName);
//    try
//        Rewrite(OutputFile);
//        WriteLn(OutputFile, 'The parameter of magic square: ', Quantity);
//        WriteLn(OutputFile, 'Program result:');
//        for I := 0 to (Quantity - 1) do
//                Write(OutputFile, Matrix[I][J], ' ');
//            WriteLn(OutputFile, '');
//
//        IsNotCorrectOpiration := False;
//    finally
//        Close(OutputFile);
//    end;
//    if (IsNotCorrectOpiration) then
//        WriteLn(' Unable to found file.');
//end;

procedure Main();
var

    OriginalArray, TestArray: TArr;
    OutputFileName: String;
begin
    WriteLn('This program performs two-way insertion sorting.');
    OriginalArray := TakeArray();
    if(OriginalArray = nil) then
        WriteLn('Input mismatch.')
    else
    begin
        TestArray := OriginalArray;
        DoubleInsertionSorting(TestArray);
        OutputFileName := ChooseFileName('lab3_3output1.txt', 'lab3_3output2.txt', 'lab3_3output3.txt');
    end;
end;

begin
    Main();
    ReadLn;
end.