"""Menu item that is used to change the current setting for an enum value."""
import subprocess

from bullet import Bullet, colors, Input, Numbers, SlidePrompt
from getch import pause

from vigorish.cli.components import print_message, yes_no_cancel_prompt, yes_no_prompt
from vigorish.cli.menu_item import MenuItem
from vigorish.config.config_setting import same_value_for_all_data_sets_is_required
from vigorish.constants import EMOJIS, MENU_NUMBERS
from vigorish.enums import ConfigType, DataSet
from vigorish.util.result import Result

NUMERIC_SETTING_UNITS = {
    "URL_SCRAPE_DELAY": "seconds",
    "BATCH_JOB_SETTINGS": "urls",
    "BATCH_SCRAPE_DELAY": "minutes",
}


class ChangeConfigSettting(MenuItem):
    def __init__(self, app, setting_name):
        super().__init__(app)
        self.menu_item_text = "Change Setting"
        self.menu_item_emoji = EMOJIS.get("SPIRAL", "")
        self.pointer = EMOJIS.get("HAND_POINTER", "")
        self.setting = self.config.all_settings.get(setting_name)
        self.setting_name_title = self.setting.setting_name_title
        self.setting_name = self.setting.setting_name
        self.data_type = self.setting.data_type
        self.possible_values = self.setting.possible_values
        self.exit_menu = False

    @property
    def enum_dict(self):
        return {
            f"{MENU_NUMBERS.get(num)}  {choice.name}": choice
            for num, choice in enumerate(self.possible_values, start=1)
        }

    @property
    def setting_units(self):
        return NUMERIC_SETTING_UNITS.get(self.setting_name, "")

    def launch(self):
        subprocess.run(["clear"])
        data_sets = self.get_data_sets_setting_will_apply_to()
        if not data_sets:
            return Result.Ok(self.exit_menu)
        setting_changed = False
        while not setting_changed:
            subprocess.run(["clear"])
            user_selections = self.get_new_setting(data_sets)
            updated_settings = self.get_updated_settings(user_selections)
            for data_set, new_value in updated_settings:
                result = self.config.change_setting(self.setting_name, data_set, new_value)
                if result.failure:
                    if "URL delay" in result.error:
                        print_message(result.error, fg="bright_red", bold=True)
                        pause(message="Press any key to continue...")
                        continue
                    return result
            setting_changed = True
        return Result.Ok(self.exit_menu)

    def get_data_sets_setting_will_apply_to(self):
        if same_value_for_all_data_sets_is_required(self.setting_name):
            return [DataSet.ALL]
        result = yes_no_cancel_prompt("Use same setting for all data sets?")
        if result.failure:
            return None
        use_same_setting = result.value
        return [DataSet.ALL] if use_same_setting else list(DataSet)

    def get_new_setting(self, data_sets):
        if self.data_type == ConfigType.NUMERIC:
            return [self.get_numeric_menu(data_set) for data_set in data_sets]
        setting_prompts = SlidePrompt(self.get_menu_prompts(data_sets))
        return setting_prompts.launch()

    def get_menu_prompts(self, data_sets):
        if self.data_type == ConfigType.ENUM:
            return [self.get_enum_menu(data_set) for data_set in data_sets]
        return [self.get_str_menu(data_set) for data_set in data_sets]

    def get_enum_menu(self, data_set):
        return Bullet(
            f"Select a value for {self.setting_name_title} (Data Set = {data_set.name}): ",
            choices=list(self.enum_dict.keys()),
            bullet="",
            shift=1,
            indent=0,
            margin=2,
            bullet_color=colors.foreground["default"],
            background_color=colors.foreground["default"],
            background_on_switch=colors.foreground["default"],
            word_color=colors.foreground["default"],
            word_on_switch=colors.bright(colors.foreground["cyan"]),
        )

    def get_str_menu(self, data_set):
        return Input(
            f"Enter a value for {self.setting_name_title} (Data Set = {data_set.name}): ",
            word_color=colors.foreground["default"],
        )

    def get_numeric_menu(self, data_set):
        if not self.setting.cannot_be_disabled:
            prompt = f"\nEnable {self.setting_name_title} (Data Set = {data_set.name})? "
            if not yes_no_prompt(prompt):
                return (prompt, (False, None, None, None, None))
        if yes_no_prompt(f"\nUse random values (Data Set = {data_set.name})? "):
            prompt, random_min, random_max, min_max_are_valid = None, 0, 0, False
            while not min_max_are_valid:
                subprocess.run(["clear"])
                prompt_min = (
                    f"Enter the minimum value (in {self.setting_units}) for "
                    f"{self.setting_name_title} (Data Set = {data_set.name}): "
                )
                prompt_max = (
                    f"Enter the maximum value (in {self.setting_units}) for "
                    f"{self.setting_name_title} (Data Set = {data_set.name}): "
                )
                random_min_prompt = Numbers(prompt_min, word_color=colors.foreground["default"])
                random_max_prompt = Numbers(prompt_max, word_color=colors.foreground["default"])
                random_min = random_min_prompt.launch()
                random_max = random_max_prompt.launch()
                if random_max > random_min:
                    min_max_are_valid = True
                    continue
                error = f"Error: maximum value ({random_max}) must be greater than minimum value ({random_min})"
                print_message(error, fg="bright_red", bold=True)
                pause(message="Press any key to continue...")
            return (prompt, (True, True, None, int(random_min), int(random_max)))
        else:
            prompt = (
                f"Enter the value (in {self.setting_units}) for {self.setting_name_title} "
                f"(Data Set = {data_set.name}): "
            )
            new_value_prompt = Numbers(prompt, word_color=colors.foreground["default"])
            new_value = new_value_prompt.launch()
            return (prompt, (True, False, int(new_value), None, None))

    def get_updated_settings(self, prompt_results):
        if self.data_type == ConfigType.ENUM:
            return self.get_updated_settings_enum(prompt_results)
        return self.get_updated_settings_str_num(prompt_results)

    def get_updated_settings_enum(self, prompt_results):
        updated_settings = []
        for prompt, selected_menu_item_text in prompt_results:
            if "ALL" in prompt:
                new_value = self.enum_dict.get(selected_menu_item_text)
                updated_settings.append((DataSet.ALL, new_value))
            for data_set in DataSet:
                if data_set.name in prompt:
                    new_value = self.enum_dict.get(selected_menu_item_text)
                    updated_settings.append((data_set, new_value))
                    break
        return updated_settings

    def get_updated_settings_str_num(self, prompt_results):
        updated_settings = []
        for prompt, new_value in prompt_results:
            if "ALL" in prompt:
                updated_settings.append((DataSet.ALL, new_value))
            for data_set in DataSet:
                if data_set.name in prompt:
                    updated_settings.append((data_set, new_value))
                    break
        return updated_settings
