Lab3_3

Program Lab3_3;

uses
  System.SysUtils;

Type
    TMatrix = Array Of Array Of Integer;
    TArr = Array Of Integer;
    TErrorCode = (CORRECT,
        INCORRECT_CHOICE,
        NON_NUMERIC,
        OUT_OF_RANGE,
        FILE_NOT_TXT,
        FILE_NOT_EXIST,
        FILE_NOT_READABLE,
        FILE_NOT_WRITABLE,
        FILE_IS_EMPTY,
        READING_GO_WRONG,
        FILE_NOT_FULL,
        FILE_NOT_CLOSE);

Const
    MIN_EXT = 5;
    MIN_ARR = 2;
    MAX_ARR = 20;
    MIN_OPTION = 1;
    MAX_OPTION = 2;
    MIN_COUNT = -999;
    MAX_COUNT = 999;
    Err: Array [TErrorCode] Of String = ('',
        'Error. Incorrect choice. Please try again.',
        'Error. Non-numeric value. Please try again. ',
        'Error. Out of Range. Please try again. ',
        'Error. File not .txt. Please try again',
        'Error. File not Exist. Please try again.',
        'Error. File not readable. Please try again.',
        'Error. File not writable. Please try again.',
        'Error. File is empty. Please try again.',
        'Error. Reading go wrong. Please try again.',
        'Error. The file lacks sufficient information.',
        'Error. File not closeble. Please try again.');

Procedure ProgramTask();
Begin
    Writeln('Sort by binary paste.');
End;

Function GetExtension(Var Str: String; PosStart, PosEnd: Integer): String;
Var
    I: Integer;
    PartStr: String;
Begin
    PartStr := '';
    For I := PosStart To PosEnd Do
        PartStr := PartStr + Str[I];
    GetExtension := PartStr;
End;

Function IsFileTxt(PathToFile: String): TErrorCode;
Var
    Error: TErrorCode;
    Size: Integer;
Begin
    Error := CORRECT;
    Size := Length(PathToFile);
    If (Size < MIN_EXT) Or (GetExtension(PathToFile, Size - 3, Size) <> '.txt') Then
        Error := FILE_NOT_TXT;
    IsFileTxt := Error;
End;

Function IsFileExist(PathToFile: String): TErrorCode;
Var
    Error: TErrorCode;
Begin
    Error := CORRECT;
    If Not FileExists(PathToFile) Then
        Error := FILE_NOT_EXIST;
    IsFileExist := Error;
End;

Function IsFileReadble(Var FileName: TextFile): TErrorCode;
Var
    Error: TErrorCode;
Begin
    Error := CORRECT;
    Try
        Reset(FileName);
    Except
        Error := FILE_NOT_EXIST
    End;
    IsFileReadble := Error;
End;

Function IsFileWritable(Var FileName: TextFile): TErrorCode;
Var
    Error: TErrorCode;
Begin
    Error := CORRECT;
    Try
        Append(FileName);
    Except
        Error := FILE_NOT_WRITABLE;
    End;
    IsFileWritable := Error;
End;

Function IsFileCloseable(Var FileName: TextFile): TErrorCode;
Var
    Error: TErrorCode;
Begin
    Error := CORRECT;
    Try
        CloseFile(FileName);
    Except
        Error := FILE_NOT_CLOSE
    End;
    IsFileCloseable := Error;
End;

Procedure GetFileNormalReading(Var FileName: TextFile);
Var
    Error: TErrorCode;
    PathToFile: String;
Begin
    Repeat
        Readln(PathToFile);
        Error := IsFileTxt(PathToFile);
        If Error = CORRECT Then
        Begin
            Error := IsFileExist(PathToFile);
            AssignFile(FileName, PathToFile);
        End;
        If Error = CORRECT Then
            Error := IsFileReadble(FileName);
        If (Error = CORRECT) And (EOF(FileName)) Then
            Error := FILE_IS_EMPTY;
        If Error <> CORRECT Then
            Writeln(ERR[Error]);
    Until Error = CORRECT;
End;

Procedure GetFileNormalWriting(Var FileName: TextFile);
Var
    Error: TErrorCode;
    PathToFile: String;
Begin
    Repeat
        Readln(PathToFile);
        Error := IsFileTxt(PathToFile);
        If Error = CORRECT Then
        Begin
            Error := IsFileExist(PathToFile);
            AssignFile(FileName, PathToFile);
        End;
        If Error = CORRECT Then
            Error := IsFileWritable(FileName);
        If Error <> CORRECT Then
            Writeln(ERR[Error]);
    Until Error = CORRECT;
End;

Function MatrixSettingFile(Var FileName: TextFile; Var Matrix: TMatrix): TErrorCode;
Var
    Error: TErrorCode;
    Rows, Cols: Integer;
Begin
    Rows := 0;
    Cols := 0;
    Writeln('Reading setings of matrix...');
    Error := CORRECT;
    Try
        Read(FileName, Rows);
        Read(FileName, Cols);
    Except
        Error := READING_GO_WRONG;
    End;
    If EOF(FileName) Then
        Error := FILE_NOT_FULL;
    If (Error = CORRECT) And (((Rows < MIN_ARR) Or (Rows > MAX_ARR)) And ((Cols < MIN_ARR) Or (Cols > MAX_ARR))) Then
        Error := OUT_OF_RANGE;
    If Error = CORRECT Then
        SetLength(Matrix, Rows, Cols);

    MatrixSettingFile := Error;
End;

Procedure MatrixSettingConsole(Var Matrix: TMatrix; Var Rows, Cols: Integer);
Var
    Error: TErrorCode;
Begin
    Repeat
        Error := CORRECT;
        Writeln('Please write size of matrix in the range ', MIN_ARR, ' .. ', MAX_ARR);
        Try
            Readln(Rows, Cols);
        Except
            Error := NON_NUMERIC;
        End;
        If (Error = CORRECT) And (((Rows < MIN_ARR) Or (Rows > MAX_ARR)) And ((Cols < MIN_ARR) Or (Cols > MAX_ARR))) Then
            Error := OUT_OF_RANGE;
        If Error <> CORRECT Then
            Write(ERR[Error]);
    Until Error = CORRECT;
    SetLength(Matrix, Rows, Cols);
End;

Procedure ReadErrorNumConsole(Var Matrix: TMatrix; Var Error: TErrorCode; Const I, J: Integer);
Begin
    Writeln(ERR[Error]);
    Repeat
        Writeln('Please write the num[', I, ',', J, ']');
        Error := CORRECT;
        Try
            Readln(Matrix[I][J]);
        Except
            Error := NON_NUMERIC;
        End;
        If (Error = CORRECT) And ((Matrix[I][J] < MIN_COUNT) Or (Matrix[I][J] > MAX_COUNT)) Then
            Error := OUT_OF_RANGE;
        Write(ERR[Error]);
    Until Error = CORRECT;
End;

Procedure ReadMatrixFromFile(Var Matrix: TMatrix);

Var
    FileName: TextFile;
    Error: TErrorCode;
    I, J: Integer;
Begin
    Repeat
        WriteLn('Enter the path to the file with extension ".txt" with matrix length and High from ', MIN_ARR, ' .. ', MAX_ARR);
        GetFileNormalReading(FileName);
        Error := MatrixSettingFile(FileName, Matrix);
        If Error = CORRECT Then
            For I := 0 To High(Matrix) Do
                For J := 0 To High(Matrix[I]) Do
                    If Not EOF(FileName) Then
                    Begin
                        Try
                            Read(FileName, Matrix[I][J]);
                        Except
                            Error := READING_GO_WRONG;
                            ReadErrorNumConsole(Matrix, Error, I, J);
                        End;
                    End
                    Else
                    Begin
                        Error := FILE_NOT_FULL;
                        ReadErrorNumConsole(Matrix, Error, I, J);
                    End;
        Error := IsFileCloseable(FileName);
        If Error <> CORRECT Then
            WriteLn(ERR[Error]);
    Until Error = CORRECT;

End;

Procedure ReadColsFromConsole(Var Matrix: TMatrix; Const I: Integer);
Var
    Error: TErrorCode;
    J: Integer;
    Num: Integer;
Begin
    WriteLn('Please enter the col ', I, ' through the space in the range ', MIN_COUNT, ' .. ', MAX_COUNT);
    Num := 0;
    For J := 0 To High(Matrix[I]) Do
        Repeat
            Error := CORRECT;
            Try
                Read(Num);
            Except
                Error := NON_NUMERIC;
            End;
            If (Error = CORRECT) And ((Num < MIN_COUNT) Or (Num > MAX_COUNT)) Then
                Error := OUT_OF_RANGE;
            If Error = CORRECT Then
                Matrix[I][J] := Num
            Else
                WriteLn(ERR[Error]);
        Until Error = CORRECT;
End;

Procedure ReadMatrixFromConsole(Var Matrix: TMatrix);
Var
    I, Rows, Cols: Integer;
Begin
    Rows := 0;
    Cols := 0;
    MatrixSettingConsole(Matrix, Rows, Cols);
    Writeln('Matrix size [', Rows, ',', Cols, ']');
    For I := 0 To High(Matrix) Do
        ReadColsFromConsole(Matrix, I);
End;

Procedure MatrixToArr(Const Matrix: TMatrix; Var Arr: TArr);
Var
    I, J, Len: Integer;
Begin
    If Length(Matrix) > Length(Matrix[0]) Then
        Len := Length(Matrix)
    Else
        Len := Length(Matrix[0]);
    Setlength(Arr, Length(Matrix) * Length(Matrix[0]));
    For I := Low(Matrix) To High(Matrix) Do
        For J := Low(Matrix[0]) To High(Matrix[0]) Do
            Arr[Len * I + J] := Matrix[I][J];
End;

Procedure ArrToMatrix(Var Matrix: TMatrix; Const Arr: TArr);
Var
    I, J, Len: Integer;
Begin
    If Length(Matrix) > Length(Matrix[0]) Then
        Len := Length(Matrix)
    Else
        Len := Length(Matrix[0]);
    For I := Low(Matrix) To High(Matrix) Do
        For J := Low(Matrix[0]) To High(Matrix[0]) Do
            Matrix[I][J] := Arr[Len * I + J];
End;

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

Procedure PrintFileArr(Const Arr: TArr; Var FileName: TextFile);
Var
    I: Integer;
Begin
    Writeln(FileName);
    For I := Low(Arr) To High(Arr) Do
    Begin
        Write(FileName, Arr[I], ' ');
    End;
    Writeln(FileName);
End;

Procedure InsertionBinary(Var Arr: TArr; Const Option: Integer; Var FileName: TextFile);
Var
    I, J, Low, Top, Point, Key: Integer;
Begin
    For I := 1 To High(Arr) Do
    Begin
        Key := Arr[I];
        Low := 0;
        Top := I - 1;
        While (Low < Top) Or (Low = Top) Do
        Begin
            Point := (Low + Top) Div 2;
            If Key < Arr[Point] Then
            Begin
                Top := Point - 1;
            End
            Else
                Low := Point + 1;
        End;
        For J := I Downto Low + 1 Do
        Begin
            Arr[J] := Arr[J - 1];
            If Option = MAX_OPTION Then
                PrintFileArr(Arr, FileName)
            Else
                PrintConsoleArr(Arr);
        End;
        Arr[Low] := Key;
    End;
    If Option = MAX_OPTION Then
        PrintFileArr(Arr, FileName)
    Else
        PrintConsoleArr(Arr);
End;

Function OptionRead(): Integer;
Var
    Error: TErrorCode;
    Option: Integer;
Begin
    Option := 0;
    Repeat
        Error := CORRECT;
        Try
            Readln(Option);
        Except
            Error := NON_NUMERIC;
        End;
        If (Error = CORRECT) And ((Option < MIN_OPTION) Or (Option > MAX_OPTION)) Then
            Error := INCORRECT_CHOICE;
        If Error <> CORRECT Then
            Write(ERR[Error]);
    Until Error = CORRECT;
    OptionRead := Option;
End;

Procedure OptionHowToRead(Var Matrix: TMatrix);
Var
    Option: Integer;
Begin
    Writeln('If you want to read from console enter: 1');
    Writeln('If you want to read from File enter:    2');
    Option := OptionRead();
    If Option = MAX_OPTION Then
        ReadMatrixFromFile(Matrix)
    Else
        ReadMatrixFromConsole(Matrix);
End;

Procedure PrintConsole(Const Matrix: TMatrix);
Var
    I, J: Integer;
Begin
    Writeln(' ');
    For I := Low(Matrix) To High(Matrix) Do
    Begin
        For J := Low(Matrix[0]) To High(Matrix[0]) Do
            Write(Matrix[I][J], ' ');
        Writeln(' ');
    End;
End;

Procedure PrintFile(Const Matrix: TMatrix; Var FileName: TextFile);
Var
    I, J: Integer;
    Error: TErrorCode;
Begin
    Repeat
        Error := CORRECT;
        Writeln(FileName);
        For I := Low(Matrix) To High(Matrix) Do
        Begin
            For J := Low(Matrix[0]) To High(Matrix[0]) Do
                Write(FileName, Matrix[I][J], ' ');
            Writeln(FileName);
        End;
        Error := IsFileCloseable(FileName);
    Until Error = CORRECT;
End;

Function PrintAnswer(Var FileName: TextFile): Integer;
Var
    Option: Integer;
    Error: TErrorCode;

Begin
    Writeln('If you want to print answer in console enter: 1');
    Writeln('If you want to print answer in File enter:    2');
    Option := OptionRead();
    If Option = MAX_OPTION Then
        Repeat
            Error := CORRECT;
            WriteLn('Enter the path to the file with extension ".txt" to get answer: ');
            GetFileNormalWriting(FileName);
        Until Error = CORRECT;
    PrintAnswer := Option;
End;

Var
    Matrix: TMatrix;
    Arr: TArr;
    Option: Integer;
    FileName: TextFile;

Begin
    ProgramTask();
    OptionHowToRead(Matrix);
    MatrixToArr(Matrix, Arr);
    Option := PrintAnswer(FileName);
    InsertionBinary(Arr, Option, FileName);
    ArrToMatrix(Matrix, Arr);
    If Option = MAX_OPTION Then
        PrintFile(Matrix, FileName)
    Else
        PrintConsole(Matrix);
    Writeln('Press Enter to exit');
    Readln;

End.