3_3 *1

program Laba_3_3;
{$APPTYPE CONSOLE}
uses
   SysUtils;

type
   TList = array of Integer;
   TInputMode = (WithFile, Console);

resourcestring
   InstructionMessage
      = 'This program sorts your sequence using Insertion Sort';
   WayOfInputMessage = 'Where do you want to input data from? [F]ile or [C]onsole';
   IncorrectInputFilePathMessage
      = 'Incorrect input file path, check if file exists and try again';
   IncorrectInputModeMessage = 'Incorrect way of input, choose [F]ile or [C]onsole';
   OutputFileExistsErrorMessage
      = 'Incorrect output file, such file already exists, try again';
   ShouldCreateMessage = 'Do you want to save output data into file? [Y]es or [N]o';
   ShouldCreateErrorMessage = 'Incorrect answer, choose [Y]es or [N]o';
   EmptySequenceMessage = 'Your sequence doesn''t contain any of assumed symbols';
   OutputMessage = 'Composed set based on your sequence';
   SuccessfullySavedMessage = 'Output data was successfully saved into ';

function GetInputFilePath: string;
var
   Path: string;
begin
   Writeln('Enter input file path');
   Readln(Path);
   while not FileExists(Path) do
   begin
      Writeln(IncorrectInputFilePathMessage);
      Readln(Path);
   end;
   GetInputFilePath := Path;
end;

function ShouldCreateOutputFile: Boolean;
var
   Answer: string;
begin
   Writeln(ShouldCreateMessage);
   Readln(Answer);
   Answer := LowerCase(Answer);
   while (Answer <> 'y') and (Answer <> 'n') do
   begin
      Writeln(ShouldCreateErrorMessage);
      Readln(Answer);
   end;
   ShouldCreateOutputFile := Answer = 'y';
end;

function GetOutputFilePath: string;
var
   Path: string;
begin
   Writeln('Enter output file path');
   Readln(Path);
   while FileExists(Path) do
   begin
      Writeln(OutputFileExistsErrorMessage);
      Readln(Path);
   end;
   GetOutputFilePath := Path;
end;

function ChooseInputMode: TInputMode;
var
   Mode: string;
begin
   Writeln(WayOfInputMessage);
   Readln(Mode);
   Mode := LowerCase(Mode);
   while (Mode <> 'c') and (Mode <> 'f') do
   begin
      Writeln(IncorrectInputModeMessage);
      Readln(Mode);
   end;
   if Mode = 'f' then
      ChooseInputMode := WithFile
   else
      ChooseInputMode := Console;
end;

function ReadFile(InputFilePath: string): TList;
var
   InputFile: TextFile;
   Sequence: TList;
   i, Item: Integer;
begin
   AssignFile(InputFile, InputFilePath);
   Reset(InputFile);

   i := 0;
   while not EoF(InputFile) do
   begin
      Read(InputFile, Item);
      Inc(i);
   end;


   SetLength(Sequence, i);
   Reset(InputFile);
   i := 0;
   while not EoF(InputFile) do
   begin
      Read(InputFile, Sequence[i]);
      Inc(i);
   end;
   CloseFile(InputFile);
   ReadFile := Sequence;
end;

function ReadConsole(): TList;
var
   N, i: Integer;
   IsCorrect: Boolean;
   List: TList;
begin
   IsCorrect := False;
   Writeln('Enter amount of elements of your sequence');
   repeat
      try
         Readln(N);
         IsCorrect := True;
      except
         Writeln('Try again');
      end;
   until IsCorrect;

   SetLength(List, N);


   IsCorrect := False;
   Writeln('Enter elems');
   for i := 0 to N - 1 do

      repeat
         try
            Read(List[i]);
            IsCorrect := True;
         except
            Writeln('Try again man');
         end;
      until IsCorrect;

   ReadConsole := List;
end;

procedure WriteList(var OutputFile: TextFile; List: TList);
var
   i, LastIndex: Integer;
begin
   LastIndex := High(List);
   for i := 0 to LastIndex do
      Write(OutputFile, List[i], ' ');

   Writeln(OutputFile, '');
end;

function SortToConsole(List: TList): TList;
var
   i, j, Current, LastIndex: Integer;
begin
   Writeln('Sorted seqeunce');
   LastIndex := High(List) + 1;
   for i := 1 to LastIndex do
   begin
      WriteList(Output, List);
      Current := List[i];
      j := i - 1;
      while (List[j] > Current) and (j >= 0) do
      begin
         List[j+1] := List[j];
         Dec(j);
         //WriteList(List);
      end;
      List[j+1] := Current;
      //WriteList('-----------------');
   end;
end;

function SortToFile(List: TList): TList;
var
   i, j, Current, LastIndex: Integer;
   OutputFile: TextFile;
begin
   Assign(OutputFile, GetOutputFilePath());
   Rewrite(OutputFile);
   LastIndex := High(List);
   Writeln(OutputFile, 'Sorted seqeunce');
   for i := 1 to LastIndex do
   begin
      WriteList(OutputFile, List);
      Current := List[i];
      j := i - 1;
      while (List[j] > Current) and (j >= 0) do
      begin
         List[j+1] := List[j];
         Dec(j);
      end;
      List[j+1] := Current;
   end;
   CloseFile(OutputFile);
end;

procedure Main;
var
   i, j, Current: Integer;
   List: TList;
   OutputFile: TextFile;
begin
   Writeln(InstructionMessage);
   case ChooseInputMode() of
      WithFile:
         List := ReadFile('input.txt'{GetInputFilePath()});
      Console:
         List := ReadConsole();
   end;

   SortToConsole(List);
   if ShouldCreateOutputFile() then
      SortToFile(List);
   Readln;
end;

begin
  Main();
end.