program lab24;

{$APPTYPE CONSOLE}
{$R *.res}

uses
    System.SysUtils, Math;

Function CheckExtension(Path: String): Boolean; forward;

Function CheckPermission(Path: String): Boolean; forward;

type
    TArray = Array [0 .. 1] of Integer;

Function InputNumber(MinNumber, MaxNumber: Integer): Integer;

var
    IsCorrect: Boolean;
    Number: Integer;

begin
    repeat
        IsCorrect := true;
        try
            Readln(Number);
        except
            Writeln('Нужно ввести целое число, которое не меньше ', MinNumber,
              ' и не больше ', MaxNumber);
            IsCorrect := false;
        end;
        if IsCorrect and ((Number < MinNumber) or (Number > MaxNumber)) then
        begin
            Writeln('Нужно ввести целое число, которое не меньше ', MinNumber,
              ' и не больше ', MaxNumber);
            IsCorrect := false;
        end;
    until IsCorrect;
    InputNumber := Number;
end;

Function ChooseWayOfInput(): Integer;

const
    CONSOLE_WAY = 1;
    FILE_WAY = 2;

var
    UserWay: Integer;

begin
    Repeat
        Writeln('Выберите способ ввода:'#13#10'Нажмите "1", если хотите ввести матрицу через консоль.'#13#10'Нажмите "2", если хотите считать матрицу из файла.');
        UserWay := InputNumber(1, 2);
    Until (UserWay = CONSOLE_WAY) or (UserWay = FILE_WAY);
    ChooseWayOfInput := UserWay;
end;

function InputPathToFile(): String;

var
    Path: String;
    IsCorrect, Flag: Boolean;
    NewFile: TextFile;
begin
    Writeln('Введите путь к файлу:');
    repeat
        repeat
            IsCorrect := true;
            Readln(Path);
            Try
                AssignFile(NewFile, Path);
                Reset(NewFile);
            Except
                Writeln('Ошибка! Путь указан неверно. Введите его заново.');
                IsCorrect := false;
            End
        Until (IsCorrect);
        Flag := CheckExtension(Path);
    until Flag;
    Close(NewFile);
    InputPathToFile := Path;
end;

Function ReceiveRangeFromConsole(): TArray;

var
    XStart, XEnd: Integer;
    Range: TArray;

begin
    Writeln('Введите первую границу.');
    XStart := InputNumber(-100, 100);
    Writeln('Введите вторую границу.');
    XEnd := InputNumber(-100, 100);
    Range[0] := XStart;
    Range[1] := XEnd;
    ReceiveRangeFromConsole := Range;
end;

Function ReceiveRangeFromFile(Path: String): TArray;

var
    InputFile: TextFile;
    Range: TArray;
    XStart, XEnd: Integer;
    IsCorrect: Boolean;

begin;
    repeat
        IsCorrect := true;
        Assign(InputFile, Path);
        Reset(InputFile);
        try
            Read(InputFile, XStart);
            Read(InputFile, XEnd);
        except
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;

    until IsCorrect;
    Range[0] := XStart;
    Range[1] := XEnd;
    ReceiveRangeFromFile := Range;
end;

procedure CheckRange(var Path: String);

const
    MIN_BORDER = -100;
    MAX_BORDER = 100;

var
    InputFile: TextFile;
    Line: String;
    XStart, XEnd: Integer;
    IsCorrect: Boolean;
begin
    repeat
        IsCorrect := true;
        Assign(InputFile, Path);
        try
            Reset(InputFile);
            Read(InputFile, XStart);
            Readln(InputFile, XEnd);
        except
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;
        if (IsCorrect) and ((XStart < MIN_BORDER) or (XStart > MAX_BORDER) or
          (XEnd < MIN_BORDER) or (XEnd > MAX_BORDER)) then
        begin
            IsCorrect := false;
            Writeln('Некорректные данные в файле!');
            Close(InputFile);
            Path := InputPathToFile;
        end;
    until IsCorrect;
    Close(InputFile);
end;

Function ReceiveRange(UserWay: Integer): TArray;

const
    CONSOLE_WAY = 1;
    FILE_WAY = 2;

var
    Path: String;
    Range: TArray;

begin;
    case UserWay of
        CONSOLE_WAY:
            begin
                Range := ReceiveRangeFromConsole();
            end;
         FILE_WAY:
            begin
                Path := InputPathToFile();
                CheckRange(Path);
                Range := ReceiveRangeFromFile(Path);
            end;
    end;
    ReceiveRange := Range;

end;

Procedure SortRange(var Range: TArray);

begin
    if (Range[0] > Range[1]) then
    begin
        Range[0] := Range[0] + Range[1];
        Range[1] := Range[0] - Range[1];
        Range[0] := Range[0] - Range[1];
    end;

end;

Function SearchMaxFunctionValue(Range: TArray): Double;

var
    X, Y, MaxValue: Double;

begin
    X := Range[0];
    MaxValue := (2 * X) / (2 * X * X - 3 * X + 4);
    while (X <= Range[1]) do
    begin
        Y := (2 * X + 3) / (2 * X * X - 3 * X + 4);
        X := X + 0.01;
        if (Y > MaxValue) then
        begin
            MaxValue := Y;
        end;
    end;
    MaxValue := SimpleRoundTo(MaxValue, -3);
    SearchMaxFunctionValue := MaxValue;
end;

Function CheckExtension(Path: String): Boolean;

var
    RigthExtension: Boolean;

begin
    if (ExtractFileExt(Path) = '.txt') then
        RigthExtension := true
    else
    begin
        Writeln('Неверное расширение файла.');
        RigthExtension := false;
    end;
    CheckExtension := RigthExtension;
end;

Function CheckPermission(Path: String): Boolean;

var
    OutputFile: TextFile;
    RightPermission: Boolean;

begin
    Assign(OutputFile, Path);
    RightPermission := true;
    try
        Rewrite(OutputFile);
        Close(OutputFile);
    except
        Writeln('Файл закрыт для записи.');
        RightPermission := false;
    end;
    CheckPermission := RightPermission;
end;

Procedure PrintResultToFile(Path: String; MaxFunctionValue: Double;
  Range: TArray);

var
    OutputFile: TextFile;

begin
    Assign(OutputFile, Path);
    Rewrite(OutputFile);
    Writeln(OutputFile,
      'Наибольшее значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [',
      Range[0], '][', Range[1], '] = ', MaxFunctionValue:4:3);
    Close(OutputFile);
end;

Procedure UserWayOfOutput(MaxFunctionValue: Double; Range: TArray);

const
    CONSOLE_WAY = '1';

var
    UserWay: Char;
    Path: String;

begin;
    Writeln('Если хотите записать результат в файл, введите "1". Если не хотите - введите другой символ:');
    Readln(UserWay);
    if (UserWay = CONSOLE_WAY) then
    begin;
        repeat
            Path := InputPathToFile();
        until (CheckPermission(Path));
        PrintResultToFile(Path, MaxFunctionValue, Range);
        Writeln('Результат записан в файл.');
    end;
end;

Procedure PrintResult(MaxFunctionValue: Double; Range: TArray);

begin;
    Writeln('Наибольшее значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [',
      Range[0], '][', Range[1], '] = ', MaxFunctionValue:4:3);
end;

Procedure Main();

var
    UserWay: Integer;
    Range: TArray;
    MaxFunctionValue: Double;

begin
    Writeln('Программа находит максимальное значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [a,b].');
    UserWay := ChooseWayOfInput();
    Range := ReceiveRange(UserWay);
    SortRange(Range);
    MaxFunctionValue := SearchMaxFunctionValue(Range);
    PrintResult(MaxFunctionValue, Range);
    UserWayOfOutput(MaxFunctionValue, Range);
    Writeln('Программа завершена.');
    Readln;
end;

begin
    Main();

end.