Lab3_2

Program Lab3_2;

uses
  System.SysUtils,
  Classes;

Type
    TSet1 = Set of AnsiChar;
    TSet2 = Set of 0..255;
    TErrorCode = (CORRECT,
                  INCORRECT_CHOICE,
                  NON_NUMERIC,
                  OUT_OF_RANGE,
                  FILE_NOT_TXT,
                  FILE_NOT_EXIST,
                  FILE_NOT_READABLE,
                  FILE_NOT_WRITABLE,
                  FILE_NOT_CLOSE,
                  FILE_IS_EMPTY,
                  READING_GO_WRONG,
                  FILE_NOT_FULL,
                  STRING_OUT_OF_RANGE,
                  TOO_MUCH);

Const
    MIN_NUM = 0;
    MAX_NUM = 255;
    MIN_EXT = 5;
    MIN_LEN = 1;
    MAX_LEN = 32;
    MIN_OPTION = 1;
    MAX_OPTION = 2;
    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 not closeble. Please try again.',
                                         'Error. File is empty. Please try again.',
                                         'Error. Reading go wrong. Please try again.',
                                         'Error. The file lacks sufficient information.',
                                         'Error. String out of Range. Please try again. ',
                                         'Error. Too much information in the file.  Please try again. ');

Procedure ProgramTask();
Begin
    Writeln('This program searches for the signs of arithmetic operations and numbers.');
End;

Function GetExtension(Const Str: String; Const 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(Const PathToFile: String): TErrorCode;
Var
    Error: TErrorCode;
    Len: Integer;
Begin
    Error := CORRECT;
    Len := Length(PathToFile);
    If (Len < MIN_EXT) Or (GetExtension(PathToFile, Len - 3, Len) <> '.txt') Then
        Error := FILE_NOT_TXT;
    IsFileTxt := Error;
End;

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

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

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

Function DoesFileCloseable(Var FileName: TextFile): TErrorCode;
Var
    Error: TErrorCode;
Begin
    Error := CORRECT;
    Try
        CloseFile(FileName);
    Except
        Error := FILE_NOT_CLOSE
    End;
    DoesFileCloseable := 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 := DoesFileExist(PathToFile);
            AssignFile(FileName, PathToFile);
        End;
        If Error = CORRECT Then
            Error := DoesFileReadable(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 := DoesFileExist(PathToFile);
            AssignFile(FileName, PathToFile);
        End;
        If Error = CORRECT Then
            Error := DoesFileWritable(FileName);
        If Error <> CORRECT Then
            Writeln(ERR[Error]);
    Until Error = CORRECT;
End;

Function ReadStringFromConsole(Const MIN_COUNT, MAX_COUNT: Integer): AnsiString;
Var
    Str: AnsiString;
    Error: TErrorCode;
Begin
    Repeat
        Writeln('Please write not empty sequence of characters, but numbers in range [0..255]');
        Error := CORRECT;
        Readln(Str);
        If (Length(Str) < MIN_COUNT) Or (Length(Str) > MAX_COUNT) Then
            Error := STRING_OUT_OF_RANGE;
        If Error <> CORRECT Then
            Write(ERR[Error]);
    Until Error = CORRECT;
    ReadStringFromConsole := Str;
End;

Function FindFileStringNumber(Var FileName: TextFile): Integer;
Var
    Counter: Integer;
Begin
    Counter := 0;
    While Not EOF(FileName) Do
    Begin
        Readln(FileName);
        Inc(Counter);
    End;
    FindFileStringNumber := Counter;
End;

Function ReadStringFromFile(Const MIN_COUNT, MAX_COUNT: Integer): AnsiString;
Var
    Counter: Integer;
    Str: AnsiString;
    FileName: TextFile;
    Error: TErrorCode;
Begin
    Repeat
        WriteLn('Enter the path to the file with extension ".txt"');
        Error := CORRECT;
        GetFileNormalReading(FileName);
        Counter := FindFileStringNumber(FileName);
        If Counter < 1 Then
            Error := FILE_NOT_FULL
        Else
            If Counter > 1 Then
                Error := TOO_MUCH;
        If Error = CORRECT Then
        Begin
            Error := DoesFileReadable(FileName);
            If Error = CORRECT Then
                Repeat
                    Error := CORRECT;
                    ReadLn(FileName, Str);
                    If (Length(Str) < MIN_COUNT) Or (Length(Str) > MAX_COUNT) Then
                        Error := STRING_OUT_OF_RANGE;
                    If Error <> CORRECT Then
                    Begin
                        Write(ERR[Error]);
                        Writeln('Please write string');
                        Str := ReadStringFromConsole(MIN_COUNT, MAX_COUNT);
                    End;
                Until Error = CORRECT;
        End
        Else
            Writeln(ERR[Error]);
        Error := DoesFileCloseable(FileName);
        If Error <> CORRECT Then
            Writeln(ERR[Error]);
    Until Error = CORRECT;
    ReadStringFromFile := Str;
End;

Function CreateSetOfArithmetic(Const Str1: AnsiString): TSet1;
Var
    Signs: TSet1;
    Ch: AnsiChar;
    I: Integer;
Begin
    Signs := [];
    For I := 1 To Length(Str1) Do
    Begin
        Ch := Str1[I];
        If ((Ord(Ch) > 38) And (Ord(Ch) < 48)) Or ((Ord(Ch) > 59) And (Ord(Ch) < 63)) Then
        Begin
            Include(Signs, Ch);
        End;
    End;
    CreateSetOfArithmetic := Signs;

End;

Function StringToNum(Const Str: AnsiString): Integer;
Var
    I, Num: Integer;

Begin
    Num := 0;
    For I := 1 To Length(Str) Do
        Num := Num * 10 + (Ord(Str[I]) - Ord('0'));
    StringToNum := Num;
End;

Function NumToString(Var Num: Integer): AnsiString;
Var
    Str: AnsiString;
Begin
    Str := '';
    Repeat
        Str := AnsiString(Chr(Ord('0') + (Num Mod 10))) + Str;
        Num := Num Div 10;
    Until Num = 0;
    NumToString := Str;
End;

Function CreateSetOfNumbers(Const Str1: AnsiString): TSet2;
Var
    Nums: TSet2;
    Temp: AnsiString;
    Ch: Ansichar;
    I, J, Len, Num: Integer;
    IsNumber: Boolean;
Begin
    Nums := [];
    Len := Length(Str1) + 1;
    I := 1;
    While I < Len Do
    Begin
        Temp := '';
        IsNumber := False;
        J := I;
        Ch := Str1[I];
        If (Ord(Ch) > 47) And (Ord(Ch) < 58) Then
            IsNumber := True;
        While IsNumber And (J < Len) Do
        Begin
            Ch := Str1[J];
            If (Ord(Ch) > 47) And (Ord(Ch) < 58) Then
            Begin
                Temp := Temp + Ch;
                Inc(J);
            End
            Else
                IsNumber := False;
        End;
        If Temp <> '' Then
        Begin
            Num := StringToNum(Temp);
        If (Num > MIN_NUM) Or (Num < MAX_NUM) Then
            Include(Nums, Num);
        End;
        I := J + 1;
    End;
    CreateSetOfNumbers := Nums;
End;

Function CreateStringSigns(Const Signs: TSet1): AnsiString;
Var
    Str: AnsiString;
    Sign: AnsiChar;
Begin
    Str := '';
    For Sign In Signs Do
        Str := Str + Sign + ' ';
    CreateStringSigns := Str;
End;

Function CreateStringNums(Const Nums: TSet2): AnsiString;
Var
    Num: Integer;
    Str: AnsiString;
Begin
    Str := '';
    For Num In Nums Do
        Str := Str + NumToString(Num) + ' ';
    CreateStringNums := Str;
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 Str: AnsiString);
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
        Str := ReadStringFromFile(MIN_LEN, MAX_LEN)
    Else
        Str := ReadStringFromConsole(MIN_LEN, MAX_LEN);
End;

Procedure PrintConsole(Const Str1, Str2: AnsiString);
Begin
    WriteLn('');
    WriteLn('Arithmetic signs');
    WriteLn(Str1);
    WriteLn('Numbers');
    WriteLn(Str2);
End;

Procedure PrintFile(Const Str1, Str2: AnsiString);
Var
    Str, Str0 : String;
    FileName: TextFile;
    Error: TErrorCode;
Begin
    Repeat
        Str := String(Str1);
        Str0 := String(Str2);
        Error := CORRECT;
        WriteLn('Enter the path to the file with extension ".txt" to get answer: ');
        GetFileNormalWriting(FileName);
        Writeln(FileName);
        WriteLn(FileName, 'Arithmetic signs');
        WriteLn(FileName, Str1);
        WriteLn(FileName, 'Numbers');
        WriteLn(FileName, Str2);
        Error := DoesFileCloseable(FileName);
        If Error <> CORRECT Then
            Writeln(ERR[Error]);
    Until Error = CORRECT;
End;

Procedure PrintAnswer(Const Str1, Str2: AnsiString);
Var
    Option: Integer;
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
        PrintFile(Str1, Str2)
    Else
        PrintConsole(Str1, Str2);
End;

Var
    Str, StrSigns, StrNumbers: AnsiString;
    Signs: TSet1;
    Numbers: TSet2;

Begin
    ProgramTask();
    OptionHowToRead(Str);
    Signs := CreateSetOfArithmetic(Str);
    Numbers := CreateSetOfNumbers(Str);
    StrSigns := CreateStringSigns(Signs);
    StrNumbers := CreateStringNums(Numbers);
    PrintAnswer(StrSigns, StrNumbers);
    Writeln('Press Enter to exit');
    Readln;

End.