from __future__ import annotations

from typing import Any, Literal

MatchSource = Literal["direct", "wildcard", "none"]


def resolve_room_config(
    token: str,
    config: dict[str, Any],
) -> dict[str, Any]:
    rooms_cfg = config.get("rooms", {})

    if not rooms_cfg:
        return {"_match_source": "none"}

    match_source: MatchSource = "wildcard"
    merged: dict[str, Any] = dict(rooms_cfg.get("*", {}))

    if rooms_cfg.get("*"):
        match_source = "wildcard"

    if token in rooms_cfg:
        merged.update(rooms_cfg[token])
        match_source = "direct"

    merged["_match_source"] = match_source
    return merged


def resolve_room_enabled(token: str, config: dict[str, Any]) -> bool:
    room_cfg = resolve_room_config(token, config)
    return room_cfg.get("enabled", room_cfg.get("enabled_", True))


def resolve_room_require_mention(token: str, config: dict[str, Any]) -> bool:
    room_cfg = resolve_room_config(token, config)
    return room_cfg.get("requireMention", room_cfg.get("require_mention", True))


def resolve_room_system_prompt(token: str, config: dict[str, Any]) -> str | None:
    room_cfg = resolve_room_config(token, config)
    return room_cfg.get("systemPrompt", room_cfg.get("system_prompt"))


def resolve_room_allow_from(token: str, config: dict[str, Any]) -> list[str]:
    room_cfg = resolve_room_config(token, config)
    return room_cfg.get("allowFrom", room_cfg.get("allow_from", []))


def resolve_room_skills(token: str, config: dict[str, Any]) -> list[str]:
    room_cfg = resolve_room_config(token, config)
    return room_cfg.get("skills", [])


def resolve_dm_config(user_id: str, config: dict[str, Any]) -> dict[str, Any]:
    dms_cfg = config.get("dms", {})
    if not dms_cfg:
        return {}
    merged: dict[str, Any] = dict(dms_cfg.get("*", {}))
    if user_id in dms_cfg:
        merged.update(dms_cfg[user_id])
    return merged


def resolve_dm_enabled(user_id: str, config: dict[str, Any]) -> bool:
    dm_cfg = resolve_dm_config(user_id, config)
    return dm_cfg.get("enabled", True)


def resolve_dm_system_prompt(user_id: str, config: dict[str, Any]) -> str | None:
    dm_cfg = resolve_dm_config(user_id, config)
    return dm_cfg.get("systemPrompt", dm_cfg.get("system_prompt"))


def resolve_dm_skills(user_id: str, config: dict[str, Any]) -> list[str]:
    dm_cfg = resolve_dm_config(user_id, config)
    return dm_cfg.get("skills", [])


def resolve_history_limit(token: str, config: dict[str, Any], chat_type: str = "group") -> int:
    if chat_type == "direct":
        dm_limit = resolve_dm_config(token, config).get("historyLimit")
        if dm_limit is not None:
            return int(dm_limit)
        return config.get("dmHistoryLimit", config.get("dm_history_limit", 0))
    room_cfg = resolve_room_config(token, config)
    room_limit = room_cfg.get("historyLimit")
    if room_limit is not None:
        return int(room_limit)
    return config.get("historyLimit", config.get("history_limit", 0))