"""
Helper utilities for Server-Authoritative Combat Engine (Sprint 2).
Handles weapon matching, element parsing, skill metadata, and support sigil resolution.
"""

from typing import Any, Dict, Optional
from server.world.martial_types import FiveElements


def extract_weapon_category(weapon: Any) -> Optional[str]:
    """Extracts string category from a weapon representation."""
    if weapon is None:
        return None
    if hasattr(weapon, "category"):
        cat = weapon.category
        return cat.value if hasattr(cat, "value") else str(cat)
    if hasattr(weapon, "value"):
        return str(weapon.value)
    return str(weapon)


def weapon_matches(weapon: Any, requirement: Any) -> bool:
    """Checks if a weapon satisfies the skill weapon requirement."""
    if requirement is None:
        return True
    req_str = requirement.value if hasattr(requirement, "value") else str(requirement)
    if req_str == "ANY":
        return True
    cat_str = extract_weapon_category(weapon)
    return cat_str == req_str


def parse_element(elem: Any) -> FiveElements:
    """Parses any elemental representation into FiveElements enum."""
    if isinstance(elem, FiveElements):
        return elem
    try:
        return FiveElements(elem)
    except Exception:
        try:
            return FiveElements[str(elem)]
        except Exception:
            return FiveElements.KIM


def resolve_skill_data(skill_id: int, skill_db: Any) -> Optional[Dict[str, Any]]:
    """Retrieves skill definition from SkillDatabaseService or canonical catalog."""
    if skill_db is not None and hasattr(skill_db, "get_skill"):
        data = skill_db.get_skill(skill_id)
        if data:
            return data
    try:
        from server.world.martial_catalog import create_standard_active_skills
        catalog = create_standard_active_skills()
        if skill_id in catalog:
            s = catalog[skill_id]
            return {
                "skill_name": s.skill_name,
                "element": s.element,
                "base_damage": s.base_damage,
                "energy_cost": s.energy_cost,
                "cooldown_ms": s.cooldown_ms,
                "animation_lock_ms": s.animation_lock_ms,
                "base_projectile_count": s.base_projectile_count,
                "weapon_requirement": s.weapon_requirement,
                "tags": [t.value if hasattr(t, "value") else str(t) for t in s.tags],
            }
    except Exception:
        pass
    return None


def resolve_sigil_data(sigil_id: int, skill_db: Any) -> Optional[Dict[str, Any]]:
    """Retrieves support sigil definition from SQLite DB or canonical catalog."""
    if skill_db is not None and hasattr(skill_db, "_get_connection"):
        try:
            with skill_db._get_connection() as conn:
                row = conn.execute("SELECT * FROM support_gems WHERE sigil_id = ?", (sigil_id,)).fetchone()
                if row:
                    return dict(row)
        except Exception:
            pass
    try:
        from server.world.martial_catalog import create_standard_augment_sigils
        catalog = create_standard_augment_sigils()
        if sigil_id in catalog:
            sig = catalog[sigil_id]
            return {
                "sigil_name": sig.sigil_name,
                "damage_multiplier": sig.damage_multiplier,
                "projectile_bonus": sig.projectile_bonus,
                "energy_cost_multiplier": sig.energy_cost_multiplier,
            }
    except Exception:
        pass
    return None