from enum import IntEnum
from typing import Any, List, Dict, Set, Callable, Optional, TextIO

from BaseClasses import ItemClassification, CollectionState, Region, Entrance, Location, Tutorial, LocationProgressType
from worlds.AutoWorld import World, WebWorld

from .Overcooked2Levels import Overcooked2Dlc, Overcooked2Level, Overcooked2GenericLevel
from .Locations import Overcooked2Location, oc2_location_name_to_id, oc2_location_id_to_name
from .Options import OC2Options, OC2OnToggle, LocationBalancingMode, DeathLinkMode
from .Items import item_table, Overcooked2Item, item_name_to_id, item_id_to_name, item_to_unlock_event, item_frequencies, dlc_exclusives
from .Logic import has_requirements_for_level_star, has_requirements_for_level_access, level_shuffle_factory, is_item_progression, is_useful


class Overcooked2Web(WebWorld):
    theme = "partyTime"

    bug_report_page = "https://github.com/toasterparty/oc2-modding/issues"
    setup_en = Tutorial(
        "Multiworld Setup Guide",
        "A guide to setting up the Overcooked! 2 randomizer on your computer.",
        "English",
        "setup_en.md",
        "setup/en",
        ["toasterparty"]
    )

    tutorials = [setup_en]


class PrepLevelMode(IntEnum):
    original = 0
    excluded = 1
    ayce = 2


class Overcooked2World(World):
    """
    Overcooked! 2 is a frantically paced arcade cooking game where
    players race against the clock to complete orders for points. Bring
    peace to the Onion Kingdom once again by recovering lost items and abilities,
    earning stars to unlock levels, and defeating the unbread horde. Levels are
    randomized to increase gameplay variety. Play with up to 4 friends.
    """

    # Autoworld API

    game = "Overcooked! 2"
    web = Overcooked2Web()
    required_client_version = (0, 3, 8)
    topology_present: bool = False

    item_name_to_id = item_name_to_id
    item_id_to_name = item_id_to_name

    location_id_to_name = oc2_location_id_to_name
    location_name_to_id = oc2_location_name_to_id

    options_dataclass = OC2Options
    options: OC2Options
    itempool: List[Overcooked2Item]

    # Helper Functions

    def is_level_horde(self, level_id: int) -> bool:
        return self.options.include_horde_levels and \
            (self.level_mapping is not None) and \
            level_id in self.level_mapping.keys() and \
            self.level_mapping[level_id].is_horde

    def create_item(self, item: str, classification: ItemClassification = ItemClassification.progression) -> Overcooked2Item:
        return Overcooked2Item(item, classification, self.item_name_to_id[item], self.player)

    def create_event(self, event: str, classification: ItemClassification) -> Overcooked2Item:
        return Overcooked2Item(event, classification, None, self.player)

    def place_event(self, location_name: str, item_name: str,
                    classification: ItemClassification = ItemClassification.progression_skip_balancing):
        location: Location = self.multiworld.get_location(location_name, self.player)
        location.place_locked_item(self.create_event(item_name, classification))

    def add_region(self, region_name: str):
        region = Region(
            region_name,
            self.player,
            self.multiworld,
        )
        self.multiworld.regions.append(region)

    def connect_regions(self, source: str, target: str, rule: Optional[Callable[[CollectionState], bool]] = None):
        sourceRegion = self.multiworld.get_region(source, self.player)
        targetRegion = self.multiworld.get_region(target, self.player)
        sourceRegion.connect(targetRegion, rule=rule)

    def add_level_location(
        self,
        region_name: str,
        location_name: str,
        level_id: int,
        stars: int,
        is_event: bool = False,
        priority=False,
    ) -> None:

        if is_event:
            location_id = None
        else:
            location_id = level_id

        region = self.multiworld.get_region(region_name, self.player)
        location = Overcooked2Location(
            self.player,
            location_name,
            location_id,
            region,
        )

        if priority:
            location.progress_type = LocationProgressType.PRIORITY
        else:
            location.progress_type = LocationProgressType.DEFAULT

        # if level_id is none, then it's the 6-6 edge case
        if level_id is None:
            level_id = 36
        if self.level_mapping is not None and level_id in self.level_mapping:
            level = self.level_mapping[level_id]
        else:
            level = Overcooked2GenericLevel(level_id)

        completion_condition: Callable[[CollectionState], bool] = \
            lambda state, level=level, stars=stars: \
            has_requirements_for_level_star(state, level, stars, self.player)
        location.access_rule = completion_condition

        region.locations.append(
            location
        )

    def get_n_random_locations(self, n: int) -> List[int]:
        """Return a list of n random non-repeating level locations"""
        levels = list()

        if n == 0:
            return levels

        for level in Overcooked2Level():
            if level.level_id == 36:
                continue
            elif not self.options.kevin_levels and level.level_id > 36:
                break

            levels.append(level.level_id)

        self.multiworld.random.shuffle(levels)
        return levels[:n]

    def get_priority_locations(self) -> List[int]:
        """Randomly generate list of priority locations, thus insulating this game
        from the negative effects of being shuffled with games that contain large
        ammounts of filler"""

        if self.multiworld.players == 1:
            # random priority locations have no desirable effect on solo seeds
            return list()

        balancing_mode = self.options.location_balancing

        if balancing_mode == LocationBalancingMode.disabled:
            # Location balancing is disabled, progression density is purely determined by filler
            return list()

        # Count how many progression items are required for this overcooked instance
        game_item_count = len(self.itempool)
        game_progression_count = 0
        for item in self.itempool:
            if item.classification == ItemClassification.progression:
                game_progression_count += 1
        game_progression_density = game_progression_count/game_item_count

        if balancing_mode == LocationBalancingMode.full:
            # Location balancing will be employed in an attempt to keep the number of
            # progression locations and proression items as close to equal as possible
            return self.get_n_random_locations(game_progression_count)

        assert balancing_mode == LocationBalancingMode.compromise

        # Count how many progression items are shuffled between all games
        total_item_count = len(self.multiworld.itempool)
        total_progression_count = 0

        for item in self.multiworld.itempool:
            if item.classification == ItemClassification.progression:
                total_progression_count += 1
        total_progression_density = total_progression_count/total_item_count

        if total_progression_density >= game_progression_density:
            # This game has more filler than the average of all other games.
            # It is not in need of location balancing
            return list()

        # Calculate the midpoint between the two ratios
        target_progression_ratio = (game_progression_density - total_progression_density) / 2.0 + total_progression_density
        target_progression_count = int((target_progression_ratio * game_item_count) + 0.5) # I'm sorry I round like an old person

        # Location balancing will be employed in an attempt to find a compromise at
        # the half-way point between natural probability and full artifical balancing
        return self.get_n_random_locations(target_progression_count)

    # Helper Data

    player_name: str
    level_unlock_counts: Dict[int, int]  # level_id, stars to purchase
    level_mapping: Dict[int, Overcooked2GenericLevel]  # level_id, level
    enabled_dlc: Set[Overcooked2Dlc]

    # Autoworld Hooks

    def generate_early(self):
        # 0.0 to 1.0 where 1.0 is World Record
        self.star_threshold_scale = self.options.star_threshold_scale / 100.0

        # Parse DLCOptionSet back into enums
        self.enabled_dlc = {Overcooked2Dlc(x) for x in self.options.include_dlcs.value}

        # Generate level unlock requirements such that the levels get harder to unlock
        # the further the game has progressed, and levels progress radially rather than linearly
        self.level_unlock_counts = level_unlock_requirement_factory(self.options.stars_to_win.value)

        # Assign new kitchens to each spot on the overworld using pure random chance and nothing else
        if self.options.shuffle_level_order:
            self.level_mapping = \
                level_shuffle_factory(
                    self.multiworld.random,
                    self.options.prep_levels != PrepLevelMode.excluded,
                    self.options.include_horde_levels.result,
                    self.options.kevin_levels.result,
                    self.enabled_dlc,
                    self.player_name,
                )
        else:
            self.level_mapping = None
            if Overcooked2Dlc.STORY not in self.enabled_dlc:
                raise Exception(f"Invalid OC2 settings({self.player_name}) Need either Level Shuffle disabled or 'Story' DLC enabled")

            self.enabled_dlc = {Overcooked2Dlc.STORY}

    def set_location_priority(self) -> None:
        priority_locations = self.get_priority_locations()
        for level in Overcooked2Level():
            if level.level_id in priority_locations:
                location: Location = self.multiworld.get_location(level.location_name_item, self.player)
                location.progress_type = LocationProgressType.PRIORITY


    def create_regions(self) -> None:
        # Menu -> Overworld
        self.add_region("Menu")
        self.add_region("Overworld")
        self.connect_regions("Menu", "Overworld")

        # Create and populate "regions" (a.k.a. levels)
        for level in Overcooked2Level():
            if not self.options.kevin_levels and level.level_id > 36:
                break

            # Create Region (e.g. "1-1")
            self.add_region(level.level_name)

            # Add Location to house progression item (1-star)
            if level.level_id == 36:
                # 6-6 doesn't have progression, but it does have victory condition which is placed later
                self.add_level_location(
                    level.level_name,
                    level.location_name_item,
                    None,
                    1,
                )
            else:
                # Location to house progression item
                self.add_level_location(
                    level.level_name,
                    level.location_name_item,
                    level.level_id,
                    1,
                )

                # Location to house level completed event
                self.add_level_location(
                    level.level_name,
                    level.location_name_level_complete,
                    level.level_id,
                    1,
                    is_event=True,
                )

            # Add Locations to house star aquisition events
            if self.is_level_horde(level.level_id):
                # in randomizer, horde levels grant a single star
                star_counts = [1]
            else:
                star_counts = [1, 2, 3]

            for n in star_counts:
                self.add_level_location(
                    level.level_name,
                    level.location_name_star_event(n),
                    level.level_id,
                    n,
                    is_event=True,
                )

            # Overworld -> Level
            required_star_count: int = self.level_unlock_counts[level.level_id]
            if level.level_id % 6 != 1 and level.level_id <= 36:
                previous_level_completed_event_name: str = Overcooked2GenericLevel(
                    level.level_id - 1).shortname.split(" ")[1] + " Level Complete"
            else:
                previous_level_completed_event_name = None

            level_access_rule: Callable[[CollectionState], bool] = \
                lambda state, level_name=level.level_name, previous_level_completed_event_name=previous_level_completed_event_name, required_star_count=required_star_count: \
                has_requirements_for_level_access(state, level_name, previous_level_completed_event_name, required_star_count, self.options.ramp_tricks.result, self.player)
            self.connect_regions("Overworld", level.level_name, level_access_rule)

            # Level --> Overworld
            self.connect_regions(level.level_name, "Overworld")

        completion_condition: Callable[[CollectionState], bool] = lambda state: \
            state.has("Victory", self.player)
        self.multiworld.completion_condition[self.player] = completion_condition


    def create_items(self):
        self.itempool = []

        # Make Items
        # useful = list()
        # filler = list()
        # progression = list()
        for item_name in item_table:            
            if item_name in item_frequencies:
                freq = item_frequencies[item_name]
            else:
                freq = 1
            
            if freq <= 0:
                # not used
                continue

            if item_name in dlc_exclusives:
                if not any(x in dlc_exclusives[item_name] for x in self.enabled_dlc):
                    # Item is always useless with these settings
                    continue

            if not self.options.include_horde_levels and item_name in ["Calmer Unbread", "Coin Purse"]:
                # skip horde-specific items if no horde levels
                continue

            if not self.options.kevin_levels:
                if item_name.startswith("Kevin"):
                    # skip kevin items if no kevin levels
                    continue

                if item_name == "Dark Green Ramp":
                    # skip dark green ramp if there's no Kevin-1 to reveal it
                    continue

            if is_item_progression(item_name, self.level_mapping, self.options.kevin_levels):
                # progression.append(item_name)
                classification = ItemClassification.progression
            else:
                if (is_useful(item_name)):
                    # useful.append(item_name)
                    classification = ItemClassification.useful
                else:
                    # filler.append(item_name)
                    classification = ItemClassification.filler

            while freq > 0:
                self.itempool.append(self.create_item(item_name, classification))
                classification = ItemClassification.useful  # only the first progressive item can be progression
                freq -= 1

        # print(f"progression: {progression}")
        # print(f"useful: {useful}")
        # print(f"filler: {filler}")

        # Fill any free space with filler
        pool_count = len(oc2_location_name_to_id)
        if not self.options.kevin_levels:
            pool_count -= 8

        while len(self.itempool) < pool_count:
            self.itempool.append(self.create_item("Bonus Star", ItemClassification.useful))

        self.multiworld.itempool += self.itempool


    def place_events(self):
        # Add Events (Star Acquisition)
        for level in Overcooked2Level():
            if not self.options.kevin_levels and level.level_id > 36:
                break

            if level.level_id != 36:
                self.place_event(level.location_name_level_complete, level.event_name_level_complete)

            if self.is_level_horde(level.level_id):
                # in randomizer, horde levels grant a single star
                star_counts = [1]
            else:
                star_counts = [1, 2, 3]

            for n in star_counts:
                self.place_event(level.location_name_star_event(n), "Star")

        # Add Victory Condition
        self.place_event("6-6 Completed", "Victory")

    def set_rules(self):
        pass

    def generate_basic(self) -> None:
        self.place_events()
        self.set_location_priority()

    # Items get distributed to locations

    def fill_json_data(self) -> Dict[str, Any]:
        mod_name = f"AP-{self.multiworld.seed_name}-P{self.player}-{self.player_name}"

        # Serialize Level Order
        story_level_order = dict()

        if self.options.shuffle_level_order:
            for level_id in self.level_mapping:
                level: Overcooked2GenericLevel = self.level_mapping[level_id]
                story_level_order[str(level_id)] = {
                    "DLC": level.dlc.value,
                    "LevelID": level.level_id,
                }

        custom_level_order = dict()
        custom_level_order["Story"] = story_level_order

        # Serialize Unlock Requirements
        level_purchase_requirements = dict()
        for level_id in self.level_unlock_counts:
            level_purchase_requirements[str(level_id)] = self.level_unlock_counts[level_id]

        # Override Vanilla Unlock Chain Behavior
        # (all worlds accessible from the start and progressible in any order)
        level_unlock_requirements = dict()
        level_force_reveal = [
            1,   # 1-1
            7,   # 2-1
            13,  # 3-1
            19,  # 4-1
            25,  # 5-1
            31,  # 6-1
        ]
        for level_id in range(1, 37):
            if (level_id not in level_force_reveal):
                level_unlock_requirements[str(level_id)] = level_id - 1

        # Set Kevin Unlock Requirements
        if self.options.kevin_levels:
            def kevin_level_to_keyholder_level_id(level_id: int) -> Optional[int]:
                location = self.multiworld.find_item(f"Kevin-{level_id-36}", self.player)
                if location.player != self.player:
                    return None  # This kevin level will be unlocked by the server at runtime
                level_id = oc2_location_name_to_id[location.name]
                return level_id

            for level_id in range(37, 45):
                keyholder_level_id = kevin_level_to_keyholder_level_id(level_id)
                if keyholder_level_id is not None:
                    level_unlock_requirements[str(level_id)] = keyholder_level_id

        # Place Items at Level Completion Screens (local only)
        on_level_completed: Dict[str, list[Dict[str, str]]] = dict()
        locations = self.multiworld.get_filled_locations(self.player)
        for location in locations:
            if location.item.code is None:
                continue  # it's an event
            if location.item.player != self.player:
                continue  # not for us
            level_id = str(oc2_location_name_to_id[location.name])
            on_level_completed[level_id] = [item_to_unlock_event(location.item.name)]

        # Put it all together
        star_threshold_scale = self.options.star_threshold_scale / 100

        base_data = {
            # Changes Inherent to rando
            "DisableAllMods": False,
            "UnlockAllChefs": True,
            "UnlockAllDLC": True,
            "DisplayFPS": True,
            "SkipTutorial": True,
            "SkipAllOnionKing": True,
            "SkipTutorialPopups": True,
            "RevealAllLevels": False,
            "PurchaseAllLevels": False,
            "CheatsEnabled": False,
            "ImpossibleTutorial": True,
            "ForbidDLC": True,
            "ForceSingleSaveSlot": True,
            "DisableNGP": True,
            "LevelForceReveal": level_force_reveal,
            "SaveFolderName": mod_name,
            "CustomOrderTimeoutPenalty": 10,
            "LevelForceHide": [37, 38, 39, 40, 41, 42, 43, 44],
            "LocalDeathLink": self.options.deathlink != DeathLinkMode.disabled,
            "BurnTriggersDeath": self.options.deathlink == DeathLinkMode.death_and_overcook,

            # Game Modifications
            "LevelPurchaseRequirements": level_purchase_requirements,
            "Custom66TimerScale": max(0.4, 0.25 + (1.0 - star_threshold_scale)*0.6),
            "ShortHordeLevels": self.options.short_horde_levels.result,
            "CustomLevelOrder": custom_level_order,

            # Items (Starting Inventory)
            "CustomOrderLifetime": 70.0,  # 100 is original
            "DisableWood": True,
            "DisableCoal": True,
            "DisableOnePlate": True,
            "DisableFireExtinguisher": True,
            "DisableBellows": True,
            "PlatesStartDirty": True,
            "MaxTipCombo": 2,
            "DisableDash": True,
            "WeakDash": True,
            "DisableThrow": True,
            "DisableCatch": True,
            "DisableControlStick": True,
            "DisableWokDrag": True,
            # "DisableRampButton": True, # Unused
            "DisableGreenRampButton" : True,
            "DisableYellowRampButton" : True,
            "DisableBlueRampButton" : True,
            "DisablePinkRampButton" : True,
            "DisableGreyRampButton" : True,
            "DisableRedRampButton" : True,
            "DisablePurpleRampButton" : True,
            "WashTimeMultiplier": 1.4,
            "BurnSpeedMultiplier": 1.43,
            "MaxOrdersOnScreenOffset": -2,
            "ChoppingTimeScale": 1.4,
            "BackpackMovementScale": 0.75,
            "RespawnTime": 10.0,
            "CarnivalDispenserRefactoryTime": 4.0,
            "LevelUnlockRequirements": level_unlock_requirements,
            "LockedEmotes": [0, 1, 2, 3, 4, 5],
            "StarOffset": 0,
            "AggressiveHorde": True,
            "DisableEarnHordeMoney": True,

            # Item Unlocking
            "OnLevelCompleted": on_level_completed,
        }

        # Set remaining data in the options dict
        bugs = ["FixDoubleServing", "FixSinkBug", "FixControlStickThrowBug", "FixEmptyBurnerThrow"]
        for bug in bugs:
            base_data[bug] = self.options.fix_bugs.result
        base_data["PreserveCookingProgress"] = self.options.always_preserve_cooking_progress.result
        base_data["TimerAlwaysStarts"] = self.options.prep_levels == PrepLevelMode.ayce
        base_data["LevelTimerScale"] = 0.666 if self.options.shorter_level_duration else 1.0
        base_data["LeaderboardScoreScale"] = {
            "FourStars": 1.0,
            "ThreeStars": star_threshold_scale,
            "TwoStars": star_threshold_scale * 0.75,
            "OneStar": star_threshold_scale * 0.35,
        }
        base_data["AlwaysServeOldestOrder"] = self.options.always_serve_oldest_order.result

        return base_data

    def fill_slot_data(self) -> Dict[str, Any]:
        return self.fill_json_data()

    def write_spoiler(self, spoiler_handle: TextIO) -> None:
        if not self.options.shuffle_level_order:
            return

        world: Overcooked2World = self
        spoiler_handle.write(f"\n\n{self.player_name}'s Level Order:\n\n")
        for overworld_id in world.level_mapping:
            overworld_name = Overcooked2GenericLevel(overworld_id).shortname.split("Story ")[1]
            kitchen_name = world.level_mapping[overworld_id].shortname
            spoiler_handle.write(f'{overworld_name} | {kitchen_name}\n')


def level_unlock_requirement_factory(stars_to_win: int) -> Dict[int, int]:
    level_unlock_counts = dict()
    level = 1
    sublevel = 1
    for n in range(1, 37):
        progress: float = float(n)/36.0
        progress *= progress  # x^2 curve

        star_count = int(progress*float(stars_to_win))
        min = (n-1)*3
        if (star_count > min):
            star_count = min

        level_id = (level-1)*6 + sublevel

        # print("%d-%d (%d) = %d" % (level, sublevel, level_id, star_count))

        level_unlock_counts[level_id] = star_count

        level += 1
        if level > 6:
            level = 1
            sublevel += 1

    # force sphere 1 to 0 stars to help keep our promises to the item fill algo
    level_unlock_counts[1] = 0  # 1-1
    level_unlock_counts[7] = 0  # 2-1
    level_unlock_counts[19] = 0  # 4-1

    # Force 5-1 into sphere 1 to help things out
    level_unlock_counts[25] = 1  # 5-1

    for n in range(37, 46):
        level_unlock_counts[n] = 0

    return level_unlock_counts