import ast
import csv
import pkgutil
import json
import re

from BaseClasses import MultiWorld, Item, ItemClassification
from enum import IntEnum
from typing import Optional, List, Union, get_args, get_origin, Any
from types import GenericAlias
from worlds.AutoWorld import World
from .hooks.Helpers import before_is_category_enabled, before_is_item_enabled, before_is_location_enabled, before_is_event_enabled


# blatantly copied from the minecraft ap world because why not
def load_data_file(*args) -> dict:
    fname = "/".join(["data", *args])

    try:
        filedata = json.loads(pkgutil.get_data(__name__, fname).decode())
    except:
        filedata = []

    return filedata

def load_data_csv(*args) -> list[dict]:
    fname = "/".join(["data", *args])

    try:
        lines = pkgutil.get_data(__name__, fname).decode().splitlines()
    except:
        lines = []
    filedata = list(csv.DictReader(lines))

    return filedata

def is_option_enabled(multiworld: MultiWorld, player: int, name: str) -> bool:
    return get_option_value(multiworld, player, name) > 0

def get_option_value(multiworld: MultiWorld, player: int, name: str) -> Union[int, dict]:
    option = getattr(multiworld.worlds[player].options, name, None)
    if option is None:
        return 0

    return option.value

def clamp(value, min, max):
    """Returns value clamped to the inclusive range of min and max"""
    if value < min:
        return min
    elif value > max:
        return max
    else:
        return value

def is_category_enabled(multiworld: MultiWorld, player: int, category_name: str) -> bool:
    from .Data import category_table
    """Check if a category has been disabled by a yaml option."""
    hook_result = before_is_category_enabled(multiworld, player, category_name)
    if hook_result is not None:
        return hook_result

    category_data = category_table.get(category_name, {})
    return resolve_yaml_option(multiworld, player, category_data)

def resolve_yaml_option(multiworld: MultiWorld, player: int, data: dict) -> bool:
    if "yaml_option" in data:
        for option_name in data["yaml_option"]:
            required = True
            if option_name.startswith("!"):
                option_name = option_name[1:]
                required = False

            option_name = format_to_valid_identifier(option_name)
            if is_option_enabled(multiworld, player, option_name) != required:
                return False
    return True

def is_item_name_enabled(multiworld: MultiWorld, player: int, item_name: str) -> bool:
    """Check if an item named 'item_name' has been disabled by a yaml option."""
    item = multiworld.worlds[player].item_name_to_item.get(item_name, {})
    if not item:
        return False

    return is_item_enabled(multiworld, player, item)

def is_item_enabled(multiworld: MultiWorld, player: int, item: dict[str, Any]) -> bool:
    """Check if an item has been disabled by a yaml option."""
    hook_result = before_is_item_enabled(multiworld, player, item)
    if hook_result is not None:
        return hook_result

    return _is_manualobject_enabled(multiworld, player, item)

def is_location_name_enabled(multiworld: MultiWorld, player: int, location_name: str) -> bool:
    """Check if a location named 'location_name' has been disabled by a yaml option."""
    location = multiworld.worlds[player].location_name_to_location.get(location_name, {})
    if not location:
        return False

    return is_location_enabled(multiworld, player, location)

def is_location_enabled(multiworld: MultiWorld, player: int, location: dict[str, Any]) -> bool:
    """Check if a location has been disabled by a yaml option."""
    if getattr(multiworld, "generation_is_fake", False):
        # When UT is doing a fake gen, give it everything
        return True

    hook_result = before_is_location_enabled(multiworld, player, location)
    if hook_result is not None:
        return hook_result

    return _is_manualobject_enabled(multiworld, player, location)

def is_event_enabled(multiworld: MultiWorld, player: int, event: dict[str, Any]) -> bool:
    """Check if an event has been disabled by a yaml option."""
    hook_result = before_is_event_enabled(multiworld, player, event)
    if hook_result is not None:
        return hook_result

    return _is_manualobject_enabled(multiworld, player, event)

def _is_manualobject_enabled(multiworld: MultiWorld, player: int, object: dict[str, Any]) -> bool:
    """Internal method: Check if a Manual Object has any category disabled by a yaml option.
    \nPlease use the proper is_'item/location'_enabled or is_'item/location'_name_enabled methods instead.
    """
    enabled = True
    for category in object.get("category", []):
        if not is_category_enabled(multiworld, player, category):
            enabled = False
            break

    return enabled

def get_items_for_player(multiworld: MultiWorld, player: int, includePrecollected: bool = False) -> List[Item]:
    """Return list of items of a player including placed items"""
    items = [i for i in multiworld.get_items() if i.player == player]
    if includePrecollected:
        items.extend(multiworld.precollected_items.get(player, []))
    return items

def reset_specific_item_value_cache_for_player(world: World, value: str, player: Optional[int] = None) -> dict[str, int]:
    if player is None:
        player = world.player
    return world.item_values[player].pop(value, {})

def reset_item_value_cache_for_player(world: World, player: Optional[int] = None):
    if player is None:
        player = world.player
    world.item_values[player] = {}

def get_items_with_value(world: World, multiworld: MultiWorld, value: str, player: Optional[int] = None, skipCache: bool = False) -> dict[str, int]:
    """Return a dict of every items with a specific value type present in their respective 'value' dict\n
    Output in the format 'Item Name': 'value count'\n
    Keep a cache of the result, it can be skipped with 'skipCache == True'\n
    To force a Reset of the player's cache of a value use either reset_specific_item_value_cache_for_player or reset_item_value_cache_for_player
    """
    if player is None:
        player = world.player

    player_items = get_items_for_player(multiworld, player, True)
    # Just a small check to prevent caching {} if items don't exist yet
    if not player_items:
        return {value: -1}

    value = value.lower().strip()

    if not skipCache:
        if not hasattr(world, 'item_values'): #Cache of just the item values
            world.item_values = {}

        if not world.item_values.get(player):
            world.item_values[player] = {}

    if value not in world.item_values.get(player, {}).keys() or skipCache:
        item_with_values = {i.name: world.item_name_to_item[i.name]['value'].get(value, 0)
                            for i in player_items if i.code is not None
                            and i.name in world.item_name_groups.get(f'has_{value}_value', [])}
        if skipCache:
            return item_with_values
        world.item_values[player][value] = item_with_values
    return world.item_values[player].get(value)


def filter_used_regions(player_regions: dict|list) -> set:
    """Return a set of regions that are actually used in Generation. It includes region that have no locations but are required by other regions\n
    The dict version of the player_regions must be in the format: dict(region name str: region)
    """
    used_regions = set()

    if isinstance(player_regions, list):
        player_regions = {r.name: r for r in player_regions}

    #Grab all the player's regions and take note of those with locations
    for region in player_regions.values():
        if region.locations:
            used_regions.add(region)

    #Check every known region with location for parent regions
    checked_parent = []
    for region in set(used_regions):
        def checkParent(parent_region):
            if parent_region.name in checked_parent: #dont check a region twice
                return
            checked_parent.append(parent_region.name)
            used_regions.add(parent_region)
            for entrance in parent_region.entrances:
                if player_regions.get(entrance.parent_region.name):
                    checkParent(entrance.parent_region)
            return
        checkParent(region)
    return used_regions

def convert_to_long_string(input: str | list[str]) -> str:
    """Verify that the input is a str. If it's a list[str] then it combine them into a str in a way that works with yaml template/website options descriptions"""
    if not isinstance(input, str):
        return str.join("\n    ", input)
    return input

def format_to_valid_identifier(input: str) -> str:
    """Make sure the input is a valid python identifier"""
    from keyword import iskeyword
    input = input.strip()
    if input.isidentifier() and not iskeyword(input):
        return input

    if iskeyword(input):
        input = "_" + input
        # if its already a valid keyword no need to check all its characters
        return input

    if input[:1].isdecimal():
        input = "_" + input

    input = "".join([c if f"_{c}".isidentifier() else "_" for c in input])

    return input

def remove_specific_item(source: list[Item], item: Item) -> Item:
    """Remove and return an item from a list in a more precise way, base AP only check for name and player id before removing.
    \nThis checks that the item IS the exact same in the list.
    \nRaise ValueError if the item is not in the list."""
    # Inspired by https://stackoverflow.com/a/58761459
    for i in range(len(source)): # check all elements of the list like a normal remove does
        if item is source[i]:
            return source.pop(i)

    # if we reach here we didn't get any item
    raise ValueError(f"Item '{item.name}' could not be found in source list")

class ProgItemsCat(IntEnum):
    VALUE = 1
    CATEGORY = 2

def format_state_prog_items_key(category: str|ProgItemsCat ,key: str) -> str:
    """Convert the inputted key to the format used in state.has(key) to check/set the count of an item_value.
    Using either one of the predefined categories or a custom string.

    Example: Coin -> MANUAL_VALUE_coin
    """
    if isinstance(category, str):
        cat_key = format_to_valid_identifier(category.upper())
    else:
        cat_key = category.name

    return f"MANUAL_{cat_key}_{format_to_valid_identifier(key.lower())}"

def convert_string_to_itemclassification(string: str) ->  ItemClassification:
    def stringCheck(string):
        if string.isdigit():
            true_class = ItemClassification(int(string))
        elif string.startswith('0b'):
            true_class = ItemClassification(int(string, base=0))
        else:
            true_class = ItemClassification[string]
        return true_class

    if "+" in string or "," in string:
        true_class = ItemClassification.filler
        for substring in re.split(r'[+,]', string):
            true_class |= stringCheck(substring.strip())

    else:
        true_class = stringCheck(string)
    return true_class

def convert_string_to_type(input: str, target_type: type) -> Any:
    """Take a string and attempt to convert it to {target_type}
    \ntarget_type can be a single type(ex. str), an union (int|str), an Optional type (Optional[str]) or a combo of any of those (Optional[int|str])
    \nSpecial logic:
    - When target_type is Optional or contains None: it will check if input.lower() is "none"
    - When target_type contains bool: it will check if input.lower() is "true", "1", "false" or "0"
    - If bool is the last type in target_type it also run the input directly through bool(input) if previous fails
    \nif you want this to possibly fail without Exceptions include str in target_type, your input should get returned if all the other conversions fails
    """
    def checktype(target_type, found_types: list):
        if issubclass(type(target_type), type): #is it a single type (str, list, etc)
            if target_type not in found_types:
                found_types.append(target_type)

        elif issubclass(type(target_type), GenericAlias): #is it something like list[str] and dict{str:int}
            if target_type not in found_types and get_origin(target_type) not in found_types: #dont add 'dict[str]' if we already search for 'dict'
                found_types.append(target_type)

        elif issubclass(type(target_type), type(str|int)) \
            or issubclass(type(target_type), type(Union[str|int])): #Support both version of Union, and Optional and other alike
            for arg in get_args(target_type):
                checktype(arg, found_types)

        else:
            raise Exception(f"'{value}' cannot be converted to {target_type} since its not a supported type \nAsk about it in #Manual-support and it might be added.")

    found_types = []
    checktype(target_type, found_types)

    if str in found_types: #do it last
        found_types.remove(str)
        found_types.append(str)

    value = input.strip()
    i = 0
    errors = []
    for value_type in found_types:
        i += 1
        if issubclass(value_type, type(None)):
            if value.lower() == 'none':
                return None
            errors.append(str(value_type) + ": value was not 'none'")

        elif issubclass(value_type, bool):
            if value.lower() in ['true', '1', 'on']:
                return True

            elif value.lower() in ['false', '0', 'off']:
                return False

            else:
                if i == len(found_types):
                    return value_type(value) #if its the last type might as well try and convert to bool
                errors.append(str(value_type) + ": value was not in either ['true', '1', 'on'] or ['false', '0', 'off']")

        elif issubclass(value_type, list) or issubclass(value_type, dict) \
            or issubclass(value_type, set) or issubclass(type(value_type), GenericAlias):
            try:
                try:
                    converted_value = ast.literal_eval(value)
                except ValueError as e:
                    # The ValueError from ast when the string cannot be evaluated as a literal is usually something like
                    # "malformed node or string on line 1: <ast.Name object at 0x000001AEBBCC7590>", which is not
                    # helpful, so re-raise with a better exception message.
                    raise ValueError(f"'{value}' could not be evaluated as a literal") from e

                compareto = get_origin(value_type) if issubclass(type(value_type), GenericAlias) else value_type
                if issubclass(compareto, type(converted_value)):
                    return converted_value
                else:
                    errors.append(str(value_type) + f": value '{value}' was not a valid {str(compareto)}")
            except Exception as e:
                errors.append(str(value_type) + ": " + str(e))
                continue
        else:
            try:
                return value_type(value)

            except Exception as e:
                errors.append(str(value_type) + ": " + str(e))
                continue

    newline = "\n"
    raise Exception(f"'{value}' could not be converted to {target_type}, here's the conversion failure message(s):\n\n{newline.join([' - ' + str(validation_error) for validation_error in errors])}\n\n")