program LabWork31;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
   TIntArr = array of Integer;

function UserChooce(): Boolean;
var
   IsCorrectChoice: Boolean;
   Choice: Char;
begin
   IsCorrectChoice := False;
   repeat
      Write('Y/N: ');
      Readln(Choice);
      Choice := UpCase(Choice);
      case Choice of
         'Y':
            begin
               IsCorrectChoice := True;
               UserChooce := True;
            end;
         'N':
            begin
               IsCorrectChoice := True;
               UserChooce := False;
            end
      else
         Writeln('You made an incorrect choice, please, try again clearly following the instructions.');
      end;
   until IsCorrectChoice;
end;


function CorrectFormatOfTheFile(FileName: String): String;
const
   FormatLen = 4;
begin
   if AnsiCompareStr(copy(FileName, length(FileName) - FormatLen + 1 , FormatLen), '.txt') <> 0 then
      FileName := FileName + '.txt';
   CorrectFormatOfTheFile := FileName;
end;

function InputFileName(): String;
var
   FileName: String;
   Input: TextFile;
   IsCorrectName: Boolean;
begin
   IsCorrectName := False;
   repeat
      Writeln('Please, enter name of the file or way to the file.');
      Writeln('Example: F:\Programming\Lab\3_1\Delphi\Input.txt');
      Readln(FileName);
      FileName := CorrectFormatOfTheFile(FileName);
      if FileExists(FileName) then
      begin
         AssignFile(Input, FileName);
         Reset(Input);
         if seekEOF(Input) then
            Writeln('Your file is empty, please, try again')
         else
            IsCorrectName := True;
         Close(Input);
      end
      else
         Writeln('File with the same name does not exists, please, try again');
   until IsCorrectName;
   InputFileName := FileName;
end;



function FindTheSizeOfTheArray(FileName: String): Integer;
var
   Input: TextFile;
   SomeNumber, Size: Integer;
begin
   AssignFile(Input, FileName);
   Reset(Input);
   Size := 1;
   try
      while not seekEOF(Input) do
      begin
         Read(Input, SomeNumber);
         Inc(Size);
      end;
   except
      Writeln('Your have have no ingegers elements');
      Size := -1;
   end;
   Close(Input);
   FindTheSizeOfTheArray := Size;
end;


function EnterArrFromFile(): TIntArr;
var
   FileName: String;
   Input: TextFile;
   UserArr: TIntArr;
   Index, SizeOfTheArr, HighIndex: Integer;
begin
   repeat
      FileName := InputFileName();
      SizeOfTheArr := FindTheSizeOfTheArray(FileName);
   until (SizeOfTheArr <> -1);
   SetLength(UserArr,  SizeOfTheArr);
   HighIndex := High(UserArr);
   AssignFile(Input, FileName);
   Reset(Input);
   Write('Your array: ');
   for Index := 0 to HighIndex do
   begin
      Read(Input, UserArr[Index]);
      Write(UserArr[Index], ' ');
   end;
   Writeln;
   EnterArrFromFile := UserArr;
end;



function EnterArrFromConsole(): TIntArr;
const
   HighInteger = 2147483647;
   LowInteger = -2147483647;
var
   Index, SizeOfTheArr, HighIndex: Integer;
   UserArr: TIntArr;
   IsCorrectNumber: Boolean;
begin
   IsCorrectNumber := False;
   repeat
      Writeln('Please, enter size of your array 0 < YourSize < ', HighInteger);
      try
         Readln(SizeOfTheArr);
         if SizeOfTheArr > 0 then
            IsCorrectNumber := True
         else
            Writeln('Error! Size must be greater than zero, please, try again.');
      except
         Writeln('You entered an incorrect value, please, try again');
      end;
   until IsCorrectNumber;
   SetLength(UserArr, SizeOfTheArr);
   Writeln('Please, enter numbers of your array ', LowInteger,' < YourNumber < ', HighInteger);
   HighIndex := High(UserArr);
   for Index := 0 to HighIndex do
      repeat
         try
            Readln(UserArr[Index]);
            IsCorrectNumber := True;
         except
            Writeln('You entered an incorrect value, please, try again');
            IsCorrectNumber := False;
         end;
      until IsCorrectNumber;
   EnterArrFromConsole := UserArr;
end;



//Èùåò èíäåêñ ïîäïîñëåäîâàòåëüíîñòè + 1
function FindFinalSequenceIndex(const UserArray: TIntArr): Integer;
var
   HighIndex, Index, i: Integer;
   IsEndOfTheSequence: Boolean;
begin
   Index := 0;
   HighIndex := High(UserArray);
   IsEndOfTheSequence := False;
   while (Index < HighIndex) and (not IsEndOfTheSequence) do
      if UserArray[Index] <= UserArray[Index + 1] then
         Inc(Index)
      else
         IsEndOfTheSequence := True;
   for i := 0 to Index do
      Write(UserArray[i], ' ');
   Write(' |  ');
   if Index = HighIndex then
      FindFinalSequenceIndex := -1
   else
      FindFinalSequenceIndex := Index + 1;
end;

//Íåïîñðåäñòâåííî ñîðòèðîâêà ñëèÿíèåì
function MergeSort(UserArray: TIntArr): TIntArr;
var
   LeftIndex, RightIndex, SortArrayIndex, IndexOfTheSequence: Integer;
   UserArrayLen, LeftPartLen, RightPartLen, i, Iteration: Integer;
   LeftPart, RightPart: TIntArr;
begin
   UserArrayLen := Length(UserArray);
   if UserArrayLen > 1 then
   begin
      IndexOfTheSequence := FindFinalSequenceIndex(UserArray);
      if IndexOfTheSequence <> -1 then
      begin
         LeftPart := copy(UserArray, 0, IndexOfTheSequence);
         RightPart := MergeSort(copy(UserArray, IndexOfTheSequence, UserArrayLen));
         LeftPartLen := Length(LeftPart);
         RightPartLen := Length(RightPart);
         Iteration := LeftPartLen - 1;
         Writeln;
         Write('Left part: ');
         for i := 0 to Iteration do
            Write(LeftPart[i], ' ');
         Writeln;
         Iteration := RightPartLen - 1;
         Write('Right part: ');
         for i := 0 to Iteration do
            Write(RightPart[i], ' ');
         Writeln;
         LeftIndex := 0;
         RightIndex := 0;
         SortArrayIndex := 0;
         SetLength(UserArray, LeftPartLen + RightPartLen);

         while (LeftIndex < LeftPartLen) and (RightIndex < RightPartLen) do
         begin
            if LeftPart[LeftIndex] <= RightPart[RightIndex] then
            begin
               UserArray[SortArrayIndex] := LeftPart[LeftIndex];
               Inc(LeftIndex);
            end
            else
            begin
               UserArray[SortArrayIndex] := RightPart[RightIndex];
               Inc(RightIndex);
            end;
            Inc(SortArrayIndex);
         end;

         while LeftIndex < LeftPartLen do
         begin
            UserArray[SortArrayIndex] := LeftPart[LeftIndex];
            Inc(LeftIndex);
            Inc(SortArrayIndex);
         end;

         while RightIndex < RightPartLen do
         begin
            UserArray[SortArrayIndex] := RightPart[RightIndex];
            Inc(RightIndex);
            Inc(SortArrayIndex);
         end;
         Write('After merge: ');
         Iteration := UserArrayLen - 1;
         for i := 0 to Iteration do
            Write(UserArray[i], ' ');
         Writeln;
         Writeln('----------');
      end;
   end
   else
      Write(UserArray[0]);
   MergeSort := UserArray;
end;


procedure Output(const UserArr: TIntArr);
var
   Output: TextFile;
   FileName: String;
   Index, HighIndex: Integer;
begin
   Writeln;
   Writeln('Sort array: ');
   HighIndex := High(UserArr);
   for Index := 0 to HighIndex do
      Write(UserArr[Index], ' ');
   Writeln;
   Writeln('Do you want to enter data to file?');
   if UserChooce() then
   begin
      Writeln('Please, enter name of the file.');
      Writeln('Example: Text.txt');
      Readln(FileName);
      FileName := CorrectFormatOfTheFile(FileName);
      AssignFile(Output, FileName);
      try
         if FileExists(FileName) then
         begin
            Write('A file with this name already exists, ');
            Writeln('do you want to append information(otherwise rewrite)?');
            if UserChooce() then
               Append(Output)
            else
               Rewrite(Output);
            end
            else
               Rewrite(Output);
      except
         Writeln('Error writing to file.');
      end;
      Writeln(Output, 'Sort array: ');
      for Index := 0 to HighIndex do
         Write(Output, UserArr[Index], ' ');
      Writeln(Output);
      CloseFile(Output);
      Writeln('Write was successfully.');
   end;
end;


procedure Main();
var
   UserArr: TIntArr;
begin
   Writeln('Hello, this program sort your array, via merge sort');
   repeat
      Writeln('Do you want to enter data through a file? (otherwise via console).');
      if UserChooce then
         UserArr := EnterArrFromFile()
      else
         UserArr := EnterArrFromConsole();
      Writeln('Our subsequence');
      Write('| ');
      Output(MergeSort(UserArr));
      Writeln('Do you want enter another array?');
   until not UserChooce();
   Writeln('Press enter to exit...');
   Readln;
end;


begin
   Main;
end.