"""Expression loader — charge et merge les fichiers YAML d'expressions par user."""

import random
from pathlib import Path

import yaml

_USERS_DIR = Path(__file__).parent.parent / "knowledge" / "users"


def _load_yaml(path: Path) -> dict:
    if not path.exists():
        return {}
    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}


def load_expressions(username: str | None) -> dict:
    """
    Charge common.yaml et le merge avec {username}.yaml.

    Retourne un dict avec :
      - nickname: str (surnom de l'user, ou username en fallback)
      - expressions: dict[situation -> list[str]]
    """
    common = _load_yaml(_USERS_DIR / "common.yaml")
    user_data = _load_yaml(_USERS_DIR / f"{username}.yaml") if username else {}

    # Merge expressions : common + user (les phrases user s'ajoutent)
    common_exprs: dict[str, list] = common.get("expressions", {})
    user_exprs: dict[str, list] = user_data.get("expressions", {})

    merged: dict[str, list] = {}
    all_situations = set(common_exprs) | set(user_exprs)
    for situation in all_situations:
        base = list(common_exprs.get(situation, []))
        extra = list(user_exprs.get(situation, []))
        merged[situation] = base + extra

    nickname = user_data.get("user", {}).get("nickname") or username or "mec"

    return {
        "nickname": nickname,
        "expressions": merged,
    }


def pick(expressions: dict, situation: str, nickname: str | None = None) -> str:
    """
    Pioche une expression aléatoire pour une situation donnée.

    Résout {user} avec le nickname si fourni.
    Retourne une string vide si la situation n'existe pas.
    """
    options = expressions.get("expressions", {}).get(situation, [])
    if not options:
        return ""
    chosen = random.choice(options)
    if nickname:
        chosen = chosen.replace("{user}", nickname)
    return chosen


def build_expressions_context(username: str | None) -> dict:
    """
    Point d'entrée principal.

    Retourne :
      - nickname: str
      - samples: dict[situation -> une phrase résolue]  — une seule par situation
    """
    data = load_expressions(username)
    nickname = data["nickname"]
    samples = {
        situation: pick(data, situation, nickname) for situation in data["expressions"]
    }
    return {
        "nickname": nickname,
        "samples": samples,
    }