Lab2ExtraDelphi

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  SysUtils;

Type
    TMatrix = Array of Array of Integer;
    TArray = Array of Integer;

Const
    PRINT_TYPE_MIN = 0;
    PRINT_TYPE_MAX = 2;

    SCAN_TYPE_MIN = 0;
    SCAN_TYPE_MAX = 1;

    MATRIX_LENGTH_MIN = 1;
    MATRIX_LENGTH_MAX = 100;
    MATRIX_VALUES_MIN = 0;
    MATRIX_VALUES_MAX = 10;

    ERR_READ_INT_VALUE = -100000000;

Function IsTextFile(FilePath: String): Boolean;
Var
    IsTxt: Boolean;
    Len: Integer;
Begin
    Len := Length(FilePath);
    IsTxt := ((Len > 2) And
        (FilePath[Len - 3] = '.') And
        (FilePath[Len - 2] = 't') And
        (FilePath[Len - 1] = 'x') And
        (FilePath[Len] = 't'));

    IsTextFile := IsTxt;
End;
Function CheckFileAvailability(FilePath: String; Read: Boolean): Boolean;
Var
    IsAvailable: Boolean;
    Checkable: TextFile;
Begin
    IsAvailable := True;
    AssignFile(Checkable, FilePath);
    Try
        If (Read) Then
            Reset(Checkable)
        Else
        Begin
            If (FileExists(FilePath)) Then
                Append(Checkable)
            Else
                Rewrite(Checkable);
        End;
        Close(Checkable);
    Except
        IsAvailable := False;
    End;

    If (IsAvailable And Not IsTextFile(FilePath)) Then
        IsAvailable := False;

    CheckFileAvailability := IsAvailable;
End;
Function TakeIntValueFromConsole(Description: String): Integer;
Var
    Value: Integer;
    IsCorrect: Boolean;
Begin
    IsCorrect := False;
    Value := 0;
    Repeat
        Write(Description);
        Try
            Readln(Value);
            IsCorrect := True;
        Except
            Writeln('Enter number, not string or anything else!');
        End;
    Until IsCorrect;

    TakeIntValueFromConsole := Value;
End;
Function TakeIntValueInRangeFromConsole(Description: String; Min: Integer; Max: Integer): Integer;
Var
    Value: Integer;
    IsCorrect: Boolean;
Begin
    Repeat
        Value := TakeIntValueFromConsole(Description);
        IsCorrect := True;
        If ((Value < Min) Or (Value > Max)) Then
        Begin
            Writeln('Value must be in range from ', Min, ' to ', Max, '!');
            IsCorrect := False;
        End;
    Until IsCorrect;

    TakeIntValueInRangeFromConsole := Value;
End;
Function TakeIntValueFromFile(Var FileToRead: TextFile): Integer;
Var
    Value: Integer;
Begin
    Try
        Read(FileToRead, Value);
    Except
        Value := ERR_READ_INT_VALUE;
    End;

    TakeIntValueFromFile := Value;
End;
Procedure TakeCorrectFile(Var FileToAssign: TextFile; Input: Boolean);
Var
    FilePath: String;
    IsCorrect: Boolean;
Begin
    Repeat
        If (Input) Then
            Write('Enter path to input file: ')
        Else
            Write('Enter path to output file: ');

        ReadLn(FilePath);
        IsCorrect := True;

        If (Not CheckFileAvailability(FilePath, Input)) Then
        Begin
            IsCorrect := False;
            WriteLn('This path contains wrong file or file, which cannot be accessed! Enter another path!');
        End;
    Until IsCorrect;

    AssignFile(FileToAssign, FilePath);
    If (Input) Then
        Reset(FileToAssign)
    Else
        Rewrite(FileToAssign);
End;

Function Calculate(Const Matrix: TMatrix; Var Goods: TArray): Integer;
Var
    I, J, NowGoods: Integer;
    IsGood: Boolean;
Begin
    NowGoods := 0;
    For I := 0 To High(Matrix) Do Begin
        J := 0;
        IsGood := True;

        While ((J < High(Matrix[I])) And IsGood) Do
        Begin
            If (Matrix[I][J] < 6) Or (Matrix[I][J] > 8) Then
                IsGood := False;
            J := J + 1;
        End;

        If (IsGood) Then
        Begin
            Goods[NowGoods] := I;
            NowGoods := NowGoods + 1;
        End;
    End;

    Calculate := NowGoods;
End;

Function ReadMatrixFromFile(): TMatrix;
Var
    Matrix: TMatrix;
    FileToRead: TextFile;
    IsCorrect: Boolean;
    I, J, N, M: Integer;
Begin
    Repeat
        TakeCorrectFile(FileToRead, True);
        M := TakeIntValueFromFile(FileToRead);
        N := TakeIntValueFromFile(FileToRead);
        IsCorrect := True;
        If (N > (MATRIX_LENGTH_MIN - 1)) And (N < (MATRIX_LENGTH_MAX + 1)) And
            (M > (MATRIX_LENGTH_MIN - 1)) And (M < (MATRIX_LENGTH_MAX + 1)) Then
        Begin
            SetLength(Matrix, M);
            For I := 0 To High(Matrix) Do Begin
                SetLength(Matrix[I], N);
                For J := 0 To High(Matrix[I]) Do
                Begin
                    Matrix[I][J] := TakeIntValueFromFile(FileToRead);
                    If (Matrix[I][J] < MATRIX_VALUES_MIN) Or (Matrix[I][J] > MATRIX_VALUES_MAX) Then
                        IsCorrect := False;
                End;
            End;
        End
        Else
        Begin
            IsCorrect := False;
            If (N < MATRIX_LENGTH_MIN) Then
                WriteLn('Matrix cannot be smaller, than ', MATRIX_LENGTH_MIN, 'x', MATRIX_LENGTH_MIN, '!');

            If (N > MATRIX_LENGTH_MAX) Then
                WriteLn('Matrix cannot be bigger, than ', MATRIX_LENGTH_MAX, 'x', MATRIX_LENGTH_MAX, '!');
        End;

        If (N > (MATRIX_LENGTH_MIN - 1)) And (N < (MATRIX_LENGTH_MAX + 1)) And
            (M > (MATRIX_LENGTH_MIN - 1)) And (M < (MATRIX_LENGTH_MAX + 1)) And Not IsCorrect Then
            WriteLn('File contains wrong values!');
    Until IsCorrect;

    ReadMatrixFromFile := Matrix;
End;
Function ReadMatrixFromConsole(): TMatrix;
Var
    M, N, I, J: Integer;
    Matrix: TMatrix;
Begin
    M := TakeIntValueInRangeFromConsole('Enter kids count (value must be in range from ' + IntToStr(MATRIX_LENGTH_MIN) + ' to ' + IntToStr(MATRIX_LENGTH_MAX) + '): ', MATRIX_LENGTH_MIN, MATRIX_LENGTH_MAX);
    N := TakeIntValueInRangeFromConsole('Enter marks count (value must be in range from ' + IntToStr(MATRIX_LENGTH_MIN) + ' to ' + IntToStr(MATRIX_LENGTH_MAX) + '): ', MATRIX_LENGTH_MIN, MATRIX_LENGTH_MAX);
    SetLength(Matrix, M);
    For I := 0 To High(Matrix) Do Begin
        SetLength(Matrix[I], N);
        For J := 0 To High(Matrix[I]) Do
            Matrix[I][J] := TakeIntValueInRangeFromConsole('Mark #' + IntToStr(I + 1) + ' for kid #' + IntToStr(J + 1) + ' (value must be in range from ' + IntToStr(MATRIX_VALUES_MIN) + ' to ' + IntToStr(MATRIX_VALUES_MAX) + '): ', MATRIX_VALUES_MIN, MATRIX_VALUES_MAX);
    End;

    ReadMatrixFromConsole := Matrix;
End;
Function ReadMatrix(): TMatrix;
Var
    ReadType: Integer;
    Matrix: TMatrix;
Begin
    WriteLn;
    WriteLn('How to read values for calculations?');
    WriteLn('0 - From keyboard (console)');
    WriteLn('1 - From file');
    ReadType := TakeIntValueInRangeFromConsole('Enter read type: ', SCAN_TYPE_MIN, SCAN_TYPE_MAX);
    If (ReadType = 1) Then
        Matrix := ReadMatrixFromFile()
    Else
        Matrix := ReadMatrixFromConsole();

    ReadMatrix := Matrix;
End;

Function SaveResultIntoFile(Const Goods: TArray; GoodsCount: Integer): Boolean;
Var
    Saved: Boolean;
    FileToSave: TextFile;
    I: Integer;
Begin
    Saved := True;
    TakeCorrectFile(FileToSave, False);

    For I := 0 To (GoodsCount - 1) Do
    Begin
        Write(FileToSave, Goods[I] + 1);
        Write(FileToSave, ' ');
    End;
    Close(FileToSave);

    SaveResultIntoFile := Saved;
End;
Procedure PrintResultIntoConsole(Const Goods: TArray; GoodsCount: Integer);
Var
    I: Integer;
Begin
    WriteLn;
    WriteLn('Indexes of goodies: ');
    For I := 0 To (GoodsCount - 1) Do
    Begin
        Write(Goods[I] + 1);
        Write(' ');
    End;
    WriteLn;
End;
Procedure PrintResult(Const Goods: TArray; GoodsCount: Integer);
Var
    WriteType: Integer;
    Saved: Boolean;

Begin
    Saved := False;
    WriteLn;
    WriteLn('Where post result?');
    WriteLn('0 - Only into console');
    WriteLn('1 - Only into file');
    WriteLn('2 - Into console and into file');
    WriteType := TakeIntValueInRangeFromConsole('Enter write type: ', PRINT_TYPE_MIN, PRINT_TYPE_MAX);
    Case WriteType Of
        0: Begin
            PrintResultIntoConsole(Goods, GoodsCount);
        End;
        1: Begin
            Saved := SaveResultIntoFile(Goods, GoodsCount);
        End;
        2: Begin
            Saved := SaveResultIntoFile(Goods, GoodsCount);
            PrintResultIntoConsole(Goods, GoodsCount);
        End;
    End;

    If (Saved) Then
        WriteLn('Result saved into file!');
End;

Var
    Matrix: TMatrix;
    Goods: TArray;
    GoodsCount: Integer;

Begin
    Matrix := ReadMatrix();
    SetLength(Goods, Length(Matrix));
    GoodsCount := Calculate(Matrix, Goods);
    PrintResult(Goods, GoodsCount);
    WriteLn('Press [ENTER] to close program...');
    ReadLn;
End.