Program Lab2Num4;

Uses
 SysUtils;

Type
 TArrOI = Array Of Integer;

Procedure OutputTaskCondition();
Begin
 Writeln('Данная программа определяет является ли последовательность, состоящая из элементов а_1, а_2,...,а_n восходящей.');
End;

Procedure OutputInputChoice();
Begin
 Write('Введите 0, если хотите ввести данные из консоли, и 1 - из файла: ');
End;

Function IsUserChoice(): Boolean;
Const
 MIN = 0;
 MAX = 1;
Var
 IsCorrect, IsChoice: Boolean;
 K: Byte;
Begin
 Repeat
 IsCorrect := True;
 Try
 Readln(K);
 Except
 Writeln('Введены некорректные данные. Повторите ввод:');
            IsCorrect := False;
        End;
        If IsCorrect And ((K > MAX) Or (K < MIN)) Then
        Begin
            Writeln('Число вне допустимого диапазона. Повторите ввод:');
            IsCorrect := False;
        End;
    Until IsCorrect;
    If (K = MIN) Then
        IsChoice := False
    Else
        IsChoice := True;
    IsUserChoice := IsChoice;
End;

Procedure OutputPathInputCondition();
Begin
    Writeln('Введите путь к файлу, содержащему последовательность: ');
End;

Function IsFileCorrect(Path: String): Boolean;
Var
    F: TextFile;
    IsCorrect: Boolean;
Begin
    IsCorrect := True;
    If Not FileExists(Path) Then
    Begin
        IsCorrect := False;
        Write('Файл по заданному пути отсутствует. ');
    End
    Else If ExtractFileExt(Path) <> '.txt' Then
    Begin
        IsCorrect := False;
        Write('Недопустимое расширение файла. ');
    End;
    If IsCorrect Then
    Begin
        AssignFile(F, Path);
        Try
            Reset(F);
        Except
            IsCorrect := False;
            Write('Файл недоступен для открытия. ');
        End;
        CloseFile(F);
    End;
    IsFileCorrect := IsCorrect;
End;

Function IsNumberOfElementsCorrect(Var InputF: TextFile): Boolean;
Const
    MIN = 2;
Var
    N: Integer;
    IsCorrect: Boolean;
Begin
    IsCorrect := True;
    Try
        Read(InputF, N);
    Except
        IsCorrect := False;
        Write('Размер массива введён некорректно. ');
    End;
    If IsCorrect And (N < MIN) Then
    Begin
        IsCorrect := False;
        Write('Слишком малый размер массива. ');
    End;
    IsNumberOfElementsCorrect := IsCorrect;
End;

Function IsDataForArrayCorrect(Var InputF: TextFile): Boolean;
Const
    NUM_MIN = 1;
Var
    N, Count, X: Integer;
    IsCorrect: Boolean;
Begin
    Count := 0;
    IsCorrect := True;
    Reset(InputF);
    Read(InputF, N);
    While Not EoF(InputF) Do
    Begin
        Try
            Read(InputF, X);
        Except
            IsCorrect := False;
        End;
        If IsCorrect And (X < NUM_MIN) Then
            IsCorrect := False;
        Inc(Count);
    End;
    If Not IsCorrect Then
        Write('Файл содержит некорректные данные. ')
    Else If (Count < N) Then
    Begin
        IsCorrect := False;
        Write('Недостаточно данных в файле. ');
    End;
    IsDataForArrayCorrect := IsCorrect;
End;

Function IsDataInFileCorrect(Path: String): Boolean;
Var
    InputF: TextFile;
    IsCorrect: Boolean;
Begin
    AssignFile(InputF, Path);
    Reset(InputF);
    IsCorrect := IsNumberOfElementsCorrect(InputF);
    If IsCorrect Then
        IsCorrect := IsDataForArrayCorrect(InputF);
    CloseFile(InputF);
    IsDataInFileCorrect := IsCorrect;
End;

Function InputPathToFileIn(): String;
Var
    Path: String;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Readln(Path);
        IsCorrect := IsFileCorrect(Path);
        If IsCorrect Then
            IsCorrect := IsDataInFileCorrect(Path);
        If Not IsCorrect Then
            Writeln('Повторите ввод пути к файлу: ');
    Until IsCorrect;
    InputPathToFileIn := Path;
End;

Function InputNumberFromFile(Path : String): Integer;
Var
    N: Integer;
    InputF: TextFile;
Begin
    AssignFile(InputF, Path);
    Reset(InputF);
    Read(InputF, N);
    CloseFile(InputF);
    InputNumberFromFile := N;
End;

Function InputArrayFromFile(Path : String; A: TArrOI): TArrOI;
Var
    I: Integer;
    Line : String;
    InputF: TextFile;
Begin
    AssignFile(InputF, Path);
    Reset(InputF);
    Readln(InputF, Line);
    For I := 0 To High(A) Do
        Readln(InputF, A[I]);
    CloseFile(InputF);
    InputArrayFromFile := A;
End;

Procedure OutputSuccessfulInput();
Begin
    Writeln('Данные из файла считаны успешно.');
End;

Procedure OutputNumberConditionForConsole();
Begin
    Writeln('Введите количество элементов в последовательности: ');
End;

Function InputNumberFromConsole(): Integer;
Const
    MIN = 2;
Var
    N: Integer;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Try
            Readln(N);
        Except
            Writeln('Введены некорректные данные. Повторите ввод:');
            IsCorrect := False;
        End;
        If IsCorrect And (N < MIN) Then
        Begin
            Writeln('Введено недопустимое число элементов. Повторите ввод:');
            IsCorrect := False;
        End;
    Until IsCorrect;
    InputNumberFromConsole := N;
End;

Procedure OutputInputConditionForConsole();
Begin
    Writeln('Поочерёдно введите натуральные числа, являющиеся элементами последовательности.');
End;

Function InputArrayFromConsole(A: TArrOI): TArrOI;
Const
    NUM_MIN = 1;
Var
    I: Integer;
    IsCorrect: Boolean;
Begin
    For I := 0 To High(A) Do
    Begin
        Repeat
            Writeln('Введите ', I + 1, ' элемент:');
            IsCorrect := True;
            Try
                Readln(A[I]);
            Except
                Writeln('Введены некорректные данные. Повторите ввод.');
                IsCorrect := False;
            End;
            If IsCorrect Then
                Writeln('Введён элемент: ', A[I]);  // Добавлен отладочный вывод
            If IsCorrect And (A[I] < NUM_MIN) Then
            Begin
                Writeln('Введённые данные не соответствуют условию. Повторите ввод.');
                IsCorrect := False;
            End;
        Until IsCorrect;
    End;
    InputArrayFromConsole := A;
End;

Function IsNonIncreasing(Sequence: TArrOI): Boolean;
Var
    I: Integer;
Begin
    Result := True;
    For I := 1 To High(Sequence) Do
    Begin
        If Sequence[I] > Sequence[I - 1] Then
        Result := False;
    End;
End;

Procedure OutputOutputChoice();
Begin
    Writeln('Введите 0, если хотите вывести данные в консоль, и 1 - в файл: ');
End;

Procedure OutputPathOutputCondition();
Begin
    Writeln('Введите путь к файлу, в который вы хотите вывести результат:');
End;

Function InputPathToFileOut(): String;
Var
    Path: String;
    IsCorrect: Boolean;
Begin
    Repeat
        IsCorrect := True;
        Readln(Path);
        IsCorrect := IsFileCorrect(Path);
        If Not IsCorrect Then
            Writeln('Повторите ввод пути к файлу:');
    Until IsCorrect;
    InputPathToFileOut := Path;
End;

Procedure OutputInFile(Var OutputF: TextFile; IsNonIncreasing: Boolean);
Begin
    If IsNonIncreasing Then
        Writeln(OutputF, 'Последовательность является невозрастающей.')
    Else
        Writeln(OutputF, 'Последовательность не является невозрастающей.');
End;

Procedure OutputSuccessfulOutput();
Begin
    Writeln('Данные записаны в файл успешно.');
End;

Procedure OutputInConsole(IsNonIncreasing: Boolean);
Begin
    If IsNonIncreasing Then
        Writeln('Последовательность является невозрастающей.')
    Else
        Writeln('Последовательность не является невозрастающей.');
End;

Function InputArray(IsInput: Boolean): TArrOI;
Var
    N: Integer;
    A: TArrOI;
    Path: String;
Begin
    If IsInput Then
    Begin
        OutputPathInputCondition();
        Path := InputPathToFileIn();
        N := InputNumberFromFile(Path);
        SetLength(A, N);
        A := InputArrayFromFile(Path, A);
        OutputSuccessfulInput();
    End
    Else
    Begin
        OutputNumberConditionForConsole();
        N := InputNumberFromConsole();
        SetLength(A, N);
        OutputInputConditionForConsole();
        A := InputArrayFromConsole(A);
    End;
    InputArray := A;
End;

Procedure OutputResult(IsOutput: Boolean; IsNotIncreasing: Boolean);
Var
    Path: String;
    OutputF: TextFile;
Begin
    If IsOutput Then
    Begin
        OutputPathOutputCondition();
        Path := InputPathToFileOut();
        AssignFile(OutputF, Path);
        Rewrite(OutputF);
        OutputInFile(OutputF, IsNotIncreasing);
        CloseFile(OutputF);
        OutputSuccessfulOutput();
    End
    Else
        OutputInConsole(IsNotIncreasing);
End;

Var
    Sequence: TArrOI;
    IsInput, IsNonIncreasingSequence, IsOutput: Boolean;
Begin
    OutputTaskCondition();
    OutputInputChoice();
    IsInput := IsUserChoice();
    Sequence := InputArray(IsInput);
    IsNonIncreasingSequence := IsNonIncreasing(Sequence);
    OutputOutputChoice();
    IsOutput := IsUserChoice();
    OutputResult(IsOutput, IsNonIncreasingSequence);
    Readln;
End.