package lab24;

import java.io.*;
import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {

    static Scanner consoleScanner = new Scanner(System.in);

    public static void main(String[] args) {
        int userWay;
        double maxFunctionValue;
        String formattedMaxFunctionValue;
        System.out.println("Программа находит максимальное значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [a,b]");
        userWay = chooseWayOfInput();
        int[] range = receiveRange(userWay);
        sortRange(range);
        maxFunctionValue = searchMaxFunctionValue(range);
        formattedMaxFunctionValue = formatValue(maxFunctionValue);
        resultOutput(formattedMaxFunctionValue, range);
        userWayOfOutput(formattedMaxFunctionValue, range);
        consoleScanner.close();
        System.out.println("Программа завершена.");
    }

    public static int inputNumber(int minNumber, int maxNumber) {
        Scanner consoleScanner = new Scanner(System.in);
        boolean isIncorrect;
        int number = 0;
        do {
            isIncorrect = false;
            try {
                number = Integer.parseInt(consoleScanner.nextLine());
            } catch (Exception ex) {
                System.out.println("Число должно быть являться целым и быть не меньше " + minNumber + " и не больше, чем " + maxNumber);
                isIncorrect = true;
            }
            if (!isIncorrect && (number < minNumber || number > maxNumber)) {
                System.out.println("Число должно быть не меньше " + minNumber + " и не больше, чем " + maxNumber);
                isIncorrect = true;
            }
        } while (isIncorrect);
        return number;
    }

    static int chooseWayOfInput() {
        int userWay;
        final int consoleNumber = 1;
        final int fileNumber = 2;
        do {
            System.out.println("Выберите способ ввода: \nНажмите '1', если хотите ввести отрезок [a,b] через консоль.\nНажмите '2', если хотите считать отрезок [a,b] из файла.");
            userWay = inputNumber(1, 2);
        } while (userWay != consoleNumber && userWay != fileNumber);
        return userWay;
    }

    static String inputPathToFile() {
        System.out.println("Введите путь к файлу:");
        boolean isIncorrect, isCorrect;
        String path;
        do {
            do {
                isIncorrect = false;
                path = consoleScanner.nextLine();
                try {
                    new FileReader(path);
                } catch (FileNotFoundException e) {
                    System.out.println("Файл не найден. Введите путь к файлу еще раз:");
                    isIncorrect = true;
                }
            } while (isIncorrect);
            isCorrect = checkExtension(path);
        }while(!isCorrect);
        return path;
    }

    static int[] receiveRangeFromFile(String path) {
        boolean isIncorrect;
        int xStart = 0;
        int xEnd = 0;
        File file = new File(path);
        do {
            isIncorrect = false;
            try {
                Scanner fileScanner = new Scanner(file);
                xStart = fileScanner.nextInt();
                xEnd = fileScanner.nextInt();
                fileScanner.close();
            } catch (Exception ex) {
                System.out.println("Некорректные данные в файле.");
                path = inputPathToFile();
                isIncorrect = true;
            }
            if (Math.abs(xStart) > 100 || Math.abs(xEnd) > 100) {
                isIncorrect = true;
                System.out.println("Некорректные данные в файле.");
                path = inputPathToFile();
            }
        } while (isIncorrect);
        return new int[]{xStart, xEnd};
    }

    static void sortRange(int[] range){
        if (range[0] > range[1])
        {
            range[0] = range[0] + range[1];
            range[1] = range[0] - range[1];
            range[0] = range[0] - range[1];
        }
    }

    static int[] receiveRange(int userWay) {
        String path;
        int[] range = null;
        switch (userWay)
        {
            case 1: {
                range = receiveRangeFromConsole();
                break;
            }
            case 2: {
                path = inputPathToFile();
                range = receiveRangeFromFile(path);
            }
        }
        return range;
    }

    static double searchMaxFunctionValue(int[] range) {
        double maxValue, y, x;
        x = range[0];
        maxValue = (2 * x) / (2 * x * x - 3 * x + 4);
        while(x <= range[1])
        {
            y = (2 * x + 3) / (2 * x * x - 3 * x + 4);
            x += 0.01;
            if (y > maxValue)
            {
                maxValue = y;
            }
        }
        return maxValue;
    }

    static String formatValue(double maxFunctionValue){
        DecimalFormat decimalFormat = new DecimalFormat("#.###");
        return decimalFormat.format(maxFunctionValue);
    }

    static void resultOutput(String formattedMaxFunctionValue, int[] range) {
        System.out.println("Наибольшее значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [" + range[0] + "," + range[1] + "] = " + formattedMaxFunctionValue);
    }

    static int[] receiveRangeFromConsole() {
        int xStart, xEnd;
        System.out.println("Введите первую границу отрезка");
        xStart = inputNumber(-100, 100);
        System.out.println("Введите вторую границу отрезка");
        xEnd = inputNumber(-100, 100);
        return new int[]{xStart, xEnd};
    }

    static boolean checkPermission(String path) {
        File file = new File(path);
        if (!file.canWrite()) {
            System.out.println("Файл закрыт для записи");
            return false;
        }
        return true;
    }

    static boolean checkExtension(String path) {
        int lastIndex;
        lastIndex = path.length() - 1;
        char[] pathToFile = path.toCharArray();
        if (pathToFile[lastIndex] != 't' || pathToFile[lastIndex - 1] != 'x' || pathToFile[lastIndex - 2] != 't' || pathToFile[lastIndex - 3] != '.')
        {
            System.out.println("Файл имеет неверное расширение. ");
            return false;
        }
        return true;
    }

    static void checkOutputFile(String path) {
        boolean isIncorrect;
        do {
            isIncorrect = false;
            if (!checkPermission(path) || !checkExtension(path)) {
                isIncorrect = true;
                path = inputPathToFile();
            }
        } while (isIncorrect);
    }

    static void printResultInFile(String path, String formattedMaxFunctionValue, int[] range) {
        try {
            FileWriter writer = new FileWriter(path);
            writer.write("Наибольшее значение функции y=(2x + 3)/(2x^2 - 3x + 4) на отрезке [" + range[0] + "," + range[1] + "] = " + formattedMaxFunctionValue);
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void userWayOfOutput(String formattedMaxFunctionValue, int[] range) {
        String userWay;
        char checkUserWay;
        System.out.println("Если хотите записать результат в файл, введите '1'. Если не хотите - введите другой символ:");
        userWay = consoleScanner.nextLine();
        checkUserWay = userWay.charAt(0);
        if (checkUserWay == '1')
        {
            String path = inputPathToFile();
            checkOutputFile(path);
            printResultInFile(path, formattedMaxFunctionValue, range);
            System.out.println("Результат записан в файл. \n");
        }
    }
}