laba23

Program Lab23;

Uses
    SysUtils;

Const
    MIN_N = 2;
    MAX_N = 100;
    MIN_A = -10000;
    MAX_A = 10000;

Type
    TMatrix = Array Of Array Of Double;

Function InputAndCheckChoice(IsCorrect: Boolean): Integer;
Var
    Choice: Integer;
Begin
    Choice := 0;
    Repeat
        IsCorrect := True;
        WriteLn('Введите ваш выбор: ');
        Try
            ReadLn(Choice);
        Except
            IsCorrect := False;
            WriteLn('Некорректный ввод. Введите 1 или 2.');
        End;

        If IsCorrect And (Choice <> 1) And (Choice <> 2) Then
        Begin
            WriteLn('Введите 1 или 2.');
            IsCorrect := False;
        End;
    Until IsCorrect;
    InputAndCheckChoice := Choice;
End;

Function InputAndCheckN(IsCorrect: Boolean): Integer;
Var
    N: Integer;
Begin
    N := 0;
    Repeat
        IsCorrect := True;
        WriteLn('Введите порядок матрицы n: ');
        Try
            ReadLn(N);
        Except
            IsCorrect := False;
            WriteLn('Некорректный ввод. Введите целое число.');
        End;

        If IsCorrect And ((N < MIN_N) Or (N > MAX_N)) Then
        Begin
            WriteLn('Диапазон значений n от ', MIN_N, ' до ', MAX_N, '. ');
            IsCorrect := False;
        End;
    Until IsCorrect;
    InputAndCheckN := N;
End;

Function IsFileExists(Const FileName: String): Boolean;
Begin
    IsFileExists := FileExists(FileName);
    If Not FileExists(FileName) Then
        WriteLn('Файл не существует.');
End;

Function IsFileTxt(Const FileName: String): Boolean;
Var
    FileType: String;
Begin
    If (Length(FileName) > 4) Then
    Begin
        FileType := FileName.SubString(FileName.Length - 4);
        If (FileType = '.txt') Then
            IsFileTxt := True
        Else
        Begin
            WriteLn('Файл не является текстовым. ');
            IsFileTxt := False;
        End;
    End
    Else
    Begin
        WriteLn('Введите корректное имя файла. ');
        IsFileTxt := False;
    End;
End;

Function IsFileNotEmpty(Var MyFile: TextFile): Boolean;
Var
    IsNotEmpty: Boolean;
Begin
    Try
        Try
            Reset(MyFile);
            IsNotEmpty := Not Eof(MyFile);
            If (Not IsNotEmpty) Then
                WriteLn('Этот файл пустой. ');
        Except
            WriteLn('Непредвиденная ошибка.');
            IsNotEmpty := False;
        End;
    Finally
        CloseFile(MyFile);
    End;
    IsFileNotEmpty := IsNotEmpty;
End;

Function IsFileWritable(Var MyFile: TextFile): Boolean;
Begin
    IsFileWritable := True;
    Try
        Rewrite(MyFile);
        Close(MyFile);
    Except
        IsFileWritable := False;
        WriteLn('Этот файл невозможно открыть для записи.');
    End;
End;

Function IsFileReadable(Var MyFile: TextFile): Boolean;
Begin
    IsFileReadable := True;
    Try
        Reset(MyFile);
        Close(MyFile);
    Except
        IsFileReadable := False;
        WriteLn('Этот файл невозможно открыть для чтения.');
    End;
End;

Function RequestFileNameForReading(Var MyFile: TextFile; IsCorrect: Boolean): String;
Var
    FileName: String;
Begin
    Repeat
        WriteLn('Введите имя файла с путём:');
        ReadLn(FileName);
        AssignFile(MyFile, FileName);
        IsCorrect := IsFileExists(FileName) And IsFileTxt(FileName) And IsFileReadable(MyFile) And IsFileNotEmpty(MyFile);
    Until IsCorrect;
    RequestFileNameForReading := FileName;
End;

Function RequestFileNameForWriting(Var MyFile: TextFile; IsCorrect: Boolean): String;
Var
    FileName: String;
Begin
    Repeat
        WriteLn('Введите имя файла с путём: ');
        ReadLn(FileName);
        AssignFile(MyFile, FileName);
        IsCorrect := IsFileExists(FileName) And IsFileTxt(FileName) And IsFileWritable(MyFile);
    Until IsCorrect;
    RequestFileNameForWriting := FileName;
End;

Procedure CreateMatrix(N: Integer; Var Matrix: TMatrix; IsCorrect: Boolean);
Var
    I, J: Integer;
Begin
    SetLength(Matrix, N, N);
    For I := 0 To High(Matrix) Do
        For J := 0 To High(Matrix) Do
        Begin
            Repeat
                IsCorrect := True;
                WriteLn('Введите элемент матрицы А', I + 1, J + 1, ': ');
                Try
                    ReadLn(Matrix[I][J]);
                Except
                    IsCorrect := False;
                    WriteLn('Некорректный ввод. Введите число.');
                End;

                If IsCorrect And ((Matrix[I][J] < MIN_A) Or (Matrix[I][J] > MAX_A)) Then
                Begin
                    WriteLn('Некорректный ввод данных.');
                    WriteLn('Диапазон значений A от ', MIN_A, ' до ', MAX_A, '. ');
                    IsCorrect := False;
                End;

            Until IsCorrect;
        End;
End;

Function InputSizeFromFile(Var Size: Integer; Var MyFile: TextFile; IsCorrect: Boolean): Boolean;
Var
    Count, N, I, J: Integer;
    Elements: TArray<String>;
    Line: String;
    TempMatrix: TMatrix;
Begin
    Line := '';
    Count := 0;
    Size := 0;
    IsCorrect := True;
    Try
        Try
            Reset(MyFile);
            While Not Eof(MyFile) Do
            Begin
                ReadLn(MyFile, Line);
                Elements := Line.Split([' ']);
                Count := Count + Length(Elements);
            End;
        Except
            WriteLn('Непредвиденная ошибка.');
            IsCorrect := False;
        End;
    Finally
        CloseFile(MyFile);
    End;
    N := Trunc(Sqrt(Count));
    If IsCorrect And (N * N = Count) And ((N > MIN_N) Or (N < MAX_N)) Then
    Begin
        SetLength(TempMatrix, N, N);
        Try
            Try
                Reset(MyFile);
                For I := 0 To N - 1 Do
                    For J := 0 To N - 1 Do
                    Begin
                        Read(MyFile, TempMatrix[I][J]);
                        If ((TempMatrix[I][J] < MIN_A) Or (TempMatrix[I][J] > MAX_A)) Then
                            IsCorrect := False;
                    End;
                If Not IsCorrect Then
                    WriteLn('Элементы матрицы выходят за диапазон допустимых значений.');
                Size := N;
            Except
                WriteLn('Матрица содержит данные неверного типа.');
                IsCorrect := False;
            End;
        Finally
            CloseFile(MyFile);
        End;
    End
    Else
    Begin
        WriteLn('Матрица должна быть квадратной. Диапазон значений n:', MIN_N, '..', MAX_N);
        IsCorrect := False;
    End;
    InputSizeFromFile := IsCorrect;
End;

Function ReadMatrix(Var MyFile: TextFile; Var Matrix: TMatrix; Const Size: Integer; IsCorrect: Boolean): Boolean;
Var
    I, J: Integer;
Begin
    SetLength(Matrix, Size, Size);
    IsCorrect := True;
    Try
        Try
            Reset(MyFile);
            For I := 0 To High(Matrix) Do
                For J := 0 To High(Matrix[I]) Do
                    Read(MyFile, Matrix[I][J]);
        Except
            WriteLn('Непредвиденная ошибка.');
            IsCorrect := False;
        End;
    Finally
        CloseFile(MyFile);
    End;
    ReadMatrix := IsCorrect;
End;

Function WriteToFile(Var MyFile: TextFile; Const Sum: Double; IsCorrect: Boolean): Boolean;
Begin
    IsCorrect := True;
    Try
        Try
            Rewrite(MyFile);
            WriteLn(MyFile, Sum:8:6);
            WriteLn('Результат выведен в файле.');
        Except
            WriteLn('Непредвиденная ошибка.');
            IsCorrect := False;
        End;
    Finally
        CloseFile(MyFile);
    End;
    WriteToFile := IsCorrect;
End;

Function SumElements(Var Matrix: TMatrix; Const N: Integer): Double;
Var
    I, J: Integer;
    Sum: Double;
Begin
    Sum := 0;
    For I := 1 To High(Matrix) Do
    Begin
        For J := 0 To I - 1 Do
            If (Matrix[I][J] > 0) Then
                Sum := Sum + Matrix[I][J];
    End;
    SumElements := Sum;
End;

Var
    N: Integer;
    Sum: Double;
    IsCorrect: Boolean;
    Choice: Integer;
    MyMatrix: TMatrix;
    MyFile: TextFile;
    MyFileName: String;

Begin
    N := 0;
    IsCorrect := False;
    WriteLn('Данная программа считает сумму положительных элементов матрицы порядка n, стоящих под главной диагональю.', #13#10,
        'Диапазон значений порядка матрицы n: ', MIN_N, '...', MAX_N, #13#10, 'Диапазон для значений элементов матрицы: ', MIN_A, '...',
        MAX_A, #13#10, 'Откуда вы хотите вводить данные?', #13#10, '1 - консоль, 2 - файл.');
    Choice := InputAndCheckChoice(IsCorrect);
    If (Choice = 1) Then
    Begin
        N := InputAndCheckN(IsCorrect);
        CreateMatrix(N, MyMatrix, IsCorrect);
    End
    Else
    Begin
        IsCorrect := False;
        Repeat
            MyFileName := RequestFileNameForReading(MyFile, IsCorrect);
            IsCorrect := InputSizeFromFile(N, MyFile, IsCorrect);
            If IsCorrect Then
            Begin
                IsCorrect := ReadMatrix(MyFile, MyMatrix, N, IsCorrect);
            End;
        Until IsCorrect;
    End;
    Sum := SumElements(MyMatrix, N);
    WriteLn('Куда Вы хотите выводить результат?', #13#10, '1 - консоль, 2 - файл.');
    Choice := InputAndCheckChoice(IsCorrect);
    If (Choice = 1) Then
    Begin
        WriteLn('Сумма равна ', Sum:8:6);
    End
    Else
    Begin
        IsCorrect := False;
        Repeat
            MyFileName := RequestFileNameForWriting(MyFile, IsCorrect);
            IsCorrect := WriteToFile(MyFile, Sum, IsCorrect);
        Until IsCorrect;
    End;
    ReadLn;

End.