Utils

def ansi_block(text: str) -> str:
    """Formats text for discord message as code block that allows for arbitrary coloring and formatting"""
    return code_block(text, "ansi")

def ansi_format(
    style: Optional[AnsiStyles] = None,
    color: Optional[AnsiColors] = None,
    background: Optional[AnsiBackgrounds] = None,
) -> str:
    """Gives format prefix for ansi code block with selected styles"""
    text_style = ";".join(str(_style.value) for _style in (style, color, background) if _style)
    return f"[{text_style}m"

def ansi_styled(
    text: str,
    style: Optional[AnsiStyles] = None,
    color: Optional[AnsiColors] = None,
    background: Optional[AnsiBackgrounds] = None,
) -> str:
    """Formats text for ansi code block with selected styles"""
    return f"{ansi_format(style, color, background)}{text}{ansi_escape}"

def bold(text: str) -> str:
    """Formats text for discord message as bold"""
    return f"**{text}**"

def code_block(text: str, language: Optional[str]) -> str:
    """Formats text for discord message as code block"""
    return f"```{language or ''}\n" f"{text}" f"```"

def inline_code(text: str) -> str:
    """Formats text for discord message as inline code"""
    return f"`{text}`"

def italic(text: str) -> str:
    """Formats text for discord message as italic"""
    return f"*{text}*"

def link_in_embed(text: str, url: str) -> str:
    """Makes a clickable link inside Embed object"""
    return f"[{text}]({url})"

def no_embed_link(url: str) -> str:
    """Makes link in discord message display without embedded website preview"""
    return f"<{url}>"

def quote_line(line: str) -> str:
    """Formats a text line for discord message as quote"""
    return f"> {line}"

def spoiler(text: str) -> str:
    """Formats text for discord message as spoiler"""
    return f"||{text}||"

def strikethrough(text: str) -> str:
    """Formats text for discord message as strikethrough"""
    return f"~~{text}~~"

def underline(text: str) -> str:
    """Formats text for discord message as underlined"""
    return f"__{text}__"

def list_converter(converter) -> Callable[[list], list]:
    """Converts a list of values to a list of converted values"""

    def convert_action(value: Union[list, Any]) -> list:
        if not isinstance(value, list):
            """If only one single item was passed (without a list), then we only convert that one item instead of throwing an exception."""
            return [converter(value)]

        return [converter(element) for element in value]

    return convert_action

def optional(converter: typing.Callable) -> typing.Any:
    """
    A modified version of attrs optional converter that supports both `None` and `MISSING`

    Type annotations will be inferred from the wrapped converter's, if it
    has any.

    Args:
        converter: The convertor that is used for the non-None or MISSING

    """

    def optional_converter(val) -> typing.Any:
        return val if val is None or val is MISSING else converter(val)

    sig = None
    try:
        sig = inspect.signature(converter)
    except (ValueError, TypeError):  # inspect failed
        pass
    if sig:
        params = list(sig.parameters.values())
        if params and params[0].annotation is not inspect.Parameter.empty:
            optional_converter.__annotations__["val"] = typing.Optional[params[0].annotation]
        if sig.return_annotation is not inspect.Signature.empty:
            optional_converter.__annotations__["return"] = typing.Optional[sig.return_annotation]

    return optional_converter

def timestamp_converter(value: Union[datetime, int, float, str]) -> Timestamp:
    """
    Converts a datetime, int, float, or str to a Timestamp object

    Args:
        value: The time value to convert

    Returns:
        A Timestamp object

    """
    try:
        if isinstance(value, str):
            return Timestamp.fromisoformat(value)
        if isinstance(value, (float, int)):
            return Timestamp.fromtimestamp(float(value))
        if isinstance(value, datetime):
            return Timestamp.fromdatetime(value)
        raise TypeError("Timestamp must be one of: datetime, int, float, ISO8601 str")
    except ValueError as e:
        interactions.const.get_logger().warning("Failed to convert timestamp", exc_info=e)
        # Should only happen if the timestamp is something stupid like 269533-01-01T00:00 - in which case we just return MISSING
        return MISSING

def attrs_validator(
    validator: Callable, skip_fields: list[str] | None = None
) -> Callable[[Any, list[Attribute]], list[Attribute]]:
    """
    Sets a validator to all fields of an attrs-dataclass.

    Args:
        validator: The validator to set
        skip_fields: A list of fields to skip adding the validator to

    Returns:
        The new fields for the attrs class

    """

    def operation(_, attributes: list[Attribute]) -> list[Attribute]:
        new_attrs = []
        for attr in attributes:
            if skip_fields and attr.name in skip_fields:
                new_attrs.append(attr)
            else:
                new_attrs.append(attr.evolve(validator=validator))
        return new_attrs

    return operation

def docs(doc_string: str) -> Dict[str, str]:
    """
    Makes it easier to quickly type attr documentation.

    Args:
        doc_string: The documentation string.

    Returns:
        The processed metadata dict

    """
    return {"docs": doc_string}

def str_validator(cls: Any, attribute: attrs.Attribute, value: Any) -> None:
    """
    Validates that the value is a string. Helps convert and ives a warning if it isn't.

    Args:
        cls: The instance of the class.
        attribute: The attr attribute being validated.
        value: The value being validated.

    """
    if not isinstance(value, str):
        if value is MISSING:
            return
        setattr(cls, attribute.name, str(value))
        get_logger().warning(
            f"Value of {attribute.name} has been automatically converted to a string. Please use strings in future.\n"
            "Note: Discord will always return value as a string"
        )

def disable_components(*components: "BaseComponent") -> list["BaseComponent"]:
    """Disables all components in a list of components."""
    for component in components:
        if component.type == ComponentType.ACTION_ROW:
            disable_components(*component.components)
        else:
            component.disabled = True
    return list(components)

def escape_mentions(content: str) -> str:
    """
    Escape mentions that could ping someone in a string.

    !!! note
        This does not escape channel mentions as they do not ping anybody

    Args:
        content: The string to escape

    Returns:
        Processed string

    """
    return mention_reg.sub("@\u200b\\1", content)

def find(predicate: Callable[[T], bool], sequence: Iterable[T]) -> Optional[T]:
    """
    Find the first element in a sequence that matches the predicate.

    ??? Hint "Example Usage:"
        ```python
        member = find(lambda m: m.name == "UserName", guild.members)
        ```
    Args:
        predicate: A callable that returns a boolean value
        sequence: A sequence to be searched

    Returns:
        A match if found, otherwise None

    """
    return next((el for el in sequence if predicate(el)), None)

def find_all(predicate: Callable[[T], bool], sequence: Iterable[T]) -> List[T]:
    """
    Find all elements in a sequence that match the predicate.

    ??? Hint "Example Usage:"
        ```python
        members = find_all(lambda m: m.name == "UserName", guild.members)
        ```
    Args:
        predicate: A callable that returns a boolean value
        sequence: A sequence to be searched

    Returns:
        A list of matches

    """
    return [el for el in sequence if predicate(el)]

def get(sequence: Iterable[T], **kwargs: Any) -> Optional[T]:
    """
    Find the first element in a sequence that matches all attrs.

    ??? Hint "Example Usage:"
        ```python
        channel = get(guild.channels, nsfw=False, category="General")
        ```

    Args:
        sequence: A sequence to be searched
        **kwargs: Keyword arguments to search the sequence for

    Returns:
        A match if found, otherwise None

    """
    if not kwargs:
        return sequence[0]

    for el in sequence:
        if any(not hasattr(el, attr) for attr in kwargs):
            continue
        if all(getattr(el, attr) == value for attr, value in kwargs.items()):
            return el
    return None

def get_all(sequence: Iterable[T], **kwargs: Any) -> List[T]:
    """
    Find all elements in a sequence that match all attrs.

    ??? Hint "Example Usage:"
        ```python
        channels = get_all(guild.channels, nsfw=False, category="General")
        ```

    Args:
        sequence: A sequence to be searched
        **kwargs: Keyword arguments to search the sequence for

    Returns:
        A list of matches

    """
    if not kwargs:
        return sequence

    matches = []
    for el in sequence:
        if any(not hasattr(el, attr) for attr in kwargs):
            continue
        if all(getattr(el, attr) == value for attr, value in kwargs.items()):
            matches.append(el)
    return matches

@functools.lru_cache(maxsize=50)
def get_event_name(event: Union[str, "events.BaseEvent"]) -> str:
    """
    Get the event name smartly from an event class or string name.

    Args:
        event: The event to parse the name of

    Returns:
        The event name

    """
    name = event

    if inspect.isclass(name) and issubclass(name, events.BaseEvent):
        name = name.__name__

    # convert CamelCase to snake_case
    name = camel_to_snake.sub(r"_\1", name).lower()
    # remove any leading underscores
    name = name.lstrip("_")
    # remove any `on_` prefixes
    name = name.removeprefix("on_")

    return name

def get_object_name(x: Any) -> str:
    """
    Gets the name of virtually any object.

    Args:
        x (Any): The object to get the name of.

    Returns:
        str: The name of the object.

    """
    try:
        return x.__name__
    except AttributeError:
        return repr(x) if hasattr(x, "__origin__") else x.__class__.__name__

def get_parameters(callback: Callable) -> dict[str, inspect.Parameter]:
    """
    Gets all the parameters of a callback.

    Args:
        callback: The callback to get the parameters of

    Returns:
        A dictionary of parameters

    """
    return {p.name: p for p in inspect.signature(callback).parameters.values()}

async def maybe_coroutine(func: Callable, *args, **kwargs) -> Any:
    """Allows running either a coroutine or a function."""
    if inspect.iscoroutinefunction(func):
        return await func(*args, **kwargs)
    return func(*args, **kwargs)

def nulled_boolean_get(data: dict[str, Any], key: str) -> bool:
    """
    Gets a boolean value from a dictionary, but treats None as True.

    Args:
        data: The dictionary to get the value from
        key: The key to get the value from

    Returns:
        The boolean value of the key

    """
    # discord tags are weird, when they are None they are True, when they are True they are True and when they are False they are False
    if key in data:
        return True if data[key] is None else bool(data[key])
    return False

def wrap_partial(obj: Any, cls: Any) -> Callable:
    """
    🎁 Wraps a commands callback objects into partials.

    !!! note
        This is used internally, you shouldn't need to use this function

    Args:
        obj: The command object to process
        cls: The class to use in partials

    Returns:
        The original command object with its callback methods wrapped

    """
    if obj.callback is None or isinstance(obj.callback, functools.partial):
        return obj
    if "_no_wrap" not in getattr(obj.callback, "__name__", ""):
        obj.callback = functools.partial(obj.callback, cls)

    if getattr(obj, "error_callback", None):
        obj.error_callback = functools.partial(obj.error_callback, cls)
    if getattr(obj, "pre_run_callback", None):
        obj.pre_run_callback = functools.partial(obj.pre_run_callback, cls)
    if getattr(obj, "post_run_callback", None):
        obj.post_run_callback = functools.partial(obj.post_run_callback, cls)
    if getattr(obj, "autocomplete_callbacks", None):
        obj.autocomplete_callbacks = {k: functools.partial(v, cls) for k, v in obj.autocomplete_callbacks.items()}
    if getattr(obj, "subcommands", None):
        obj.subcommands = {k: wrap_partial(v, cls) for k, v in obj.subcommands.items()}

    return obj