"""World calendar + trigger firing helpers.

Triggers fire on changes to in-world time (NOT real-time polling). When the
orchestrator advances world time (via the `advance_time` tool or the
`time_advance` field in a plan), the engine checks all unfired triggers for
that session and fires any whose `fire_at` is now <= the new world time.

Each world may define its own calendar via `world.definition.calendar`:
  {
    "hours_per_day": 24,        # default 24
    "days_per_week": 7,         # informational only (not used in math)
    "minutes_per_hour": 60      # default 60
  }

World time is stored as a string "day_{D}_hour_{H}" (we don't track minutes
in the string to keep it compact — minutes are tracked separately in
world.state.world_time if needed).

The trigger's `fire_at` is also a "day_D_hour_H" string. We compare by
totaling the in-world minutes since day-0-hour-0 for each side.
"""
from __future__ import annotations

import json
import re
import uuid
from typing import Any, Dict, List, Optional, Tuple

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.llm import LlmClient
from app.core.settings_service import get_all_settings
from app.core.state_validator import apply_patch, validate_state
from app.engine.tools.tools import TRIGGER_RUNNER_TOOL_SCHEMAS
from app.logging_setup import get_logger
from app.models import DeferredTrigger, Message, Session, World
from app.prompts.templates import get_prompt

log = get_logger("triggers")


_TIME_RE = re.compile(r"^day_(\d+)_hour_(\d+)(?:_min_(\d+))?$")


def get_calendar(world: World) -> Dict[str, int]:
    """Return the world's calendar config with defaults applied."""
    defn = world.definition or {}
    cal = (defn.get("calendar") or {}) if isinstance(defn, dict) else {}
    return {
        "hours_per_day": int(cal.get("hours_per_day", 24) or 24),
        "minutes_per_hour": int(cal.get("minutes_per_hour", 60) or 60),
        "days_per_week": int(cal.get("days_per_week", 7) or 7),
    }


def parse_world_time(t: Optional[str], cal: Dict[str, int]) -> int:
    """Parse 'day_D_hour_H[_min_M]' into total in-world minutes since day 0 hour 0.

    Returns 0 for unparseable input (so triggers with bad fire_at fire
    immediately rather than never — fail-open for visibility).
    """
    if not t:
        return 0
    m = _TIME_RE.match(t.strip())
    if not m:
        # Try ISO datetime as a fallback (rare).
        try:
            from datetime import datetime
            return int(datetime.fromisoformat(t).timestamp() // 60)
        except Exception:
            return 0
    day = int(m.group(1))
    hour = int(m.group(2))
    minute = int(m.group(3) or 0)
    hours_per_day = max(1, cal.get("hours_per_day", 24))
    minutes_per_hour = max(1, cal.get("minutes_per_hour", 60))
    return day * hours_per_day * minutes_per_hour + hour * minutes_per_hour + minute


def format_world_time(total_minutes: int, cal: Dict[str, int]) -> str:
    """Inverse of parse_world_time: total minutes -> 'day_D_hour_H' string."""
    hours_per_day = max(1, cal.get("hours_per_day", 24))
    minutes_per_hour = max(1, cal.get("minutes_per_hour", 60))
    minutes_per_day = hours_per_day * minutes_per_hour
    day = total_minutes // minutes_per_day
    rem = total_minutes % minutes_per_day
    hour = rem // minutes_per_hour
    minute = rem % minutes_per_hour
    if minute:
        return f"day_{day}_hour_{hour}_min_{minute}"
    return f"day_{day}_hour_{hour}"


def advance_world_time(
    current_time: Optional[str],
    advance: Dict[str, int],
    world: World,
) -> Tuple[str, int, int]:
    """Advance world time by days/hours/minutes, honoring the world's calendar.

    Returns (new_time_string, new_total_minutes, delta_minutes).
    """
    cal = get_calendar(world)
    cur_total = parse_world_time(current_time, cal)
    hours_per_day = cal["hours_per_day"]
    minutes_per_hour = cal["minutes_per_hour"]
    delta = (
        int(advance.get("days", 0)) * hours_per_day * minutes_per_hour
        + int(advance.get("hours", 0)) * minutes_per_hour
        + int(advance.get("minutes", 0))
    )
    new_total = cur_total + delta
    new_str = format_world_time(new_total, cal)

    # Also update world_time in state if present.
    if world.state and isinstance(world.state, dict) and "world_time" in world.state:
        wt = world.state["world_time"]
        if isinstance(wt, dict):
            day = new_total // (hours_per_day * minutes_per_hour)
            rem = new_total % (hours_per_day * minutes_per_hour)
            hour = rem // minutes_per_hour
            minute = rem % minutes_per_hour
            wt["day"] = day
            wt["hour"] = hour
            wt["minute"] = minute
            wt["hours_per_day"] = hours_per_day
            wt["minutes_per_hour"] = minutes_per_hour

    return new_str, new_total, delta


async def fire_due_triggers(
    db: AsyncSession,
    session_id: uuid.UUID,
    world: World,
    settings_map: Optional[Dict[str, Any]] = None,
    user_id: Optional[uuid.UUID] = None,
) -> List[Dict[str, Any]]:
    """Fire all due triggers for this session.

    "Due" = trigger.fired is False AND parse_world_time(trigger.fire_at) <=
    parse_world_time(world.current_time).

    Each fired trigger:
      1. Calls the LLM (trigger_runner prompt) to produce narrative + state patch.
      2. Applies the state patch to the world.
      3. Saves a Message (visible if should_notify_player, hidden otherwise).
      4. Marks trigger.fired = True.

    Returns a list of fired trigger dicts (for the orchestrator to include in
    the step_complete event).
    """
    cal = get_calendar(world)
    cur_total = parse_world_time(world.current_time, cal)

    result = await db.execute(
        select(DeferredTrigger).where(
            DeferredTrigger.session_id == session_id,
            DeferredTrigger.fired.is_(False),
        )
    )
    triggers = list(result.scalars().all())
    if not triggers:
        return []

    # Sort by fire_at ascending so they fire in chronological order.
    triggers.sort(key=lambda t: parse_world_time(t.fire_at, cal))

    fired: List[Dict[str, Any]] = []
    for trigger in triggers:
        if parse_world_time(trigger.fire_at, cal) > cur_total:
            continue  # not due yet
        try:
            await _fire_one(db, trigger, session_id, world, settings_map, user_id)
            fired.append({
                "id": str(trigger.id),
                "fire_at": trigger.fire_at,
                "description": trigger.description,
                "payload": trigger.payload,
            })
        except Exception as e:
            log.error(
                "trigger_fire_failed",
                trigger_id=str(trigger.id),
                session_id=str(session_id),
                error=f"{type(e).__name__}: {e}",
            )
            # Mark as fired anyway so we don't retry forever on a broken trigger.
            trigger.fired = True
    if fired:
        await db.commit()
    return fired


async def _fire_one(
    db: AsyncSession,
    trigger: DeferredTrigger,
    session_id: uuid.UUID,
    world: World,
    settings_map: Optional[Dict[str, Any]],
    user_id: Optional[uuid.UUID],
) -> None:
    """Fire a single trigger: produce narrative + apply state patch.

    Uses the `submit_trigger_result` tool (tool-calling-first design) to get
    structured output from the LLM.
    """
    if settings_map is None:
        settings_map = await get_all_settings(db)
    llm = LlmClient(settings_map)

    # Trigger-runner prompt is always English (system content convention);
    # the LLM produces player-facing narrative in world.language (interpolated).
    system_prompt = get_prompt("trigger_runner", "en").format(
        description=trigger.description,
        payload=json.dumps(trigger.payload, ensure_ascii=False)[:600],
        state=json.dumps(world.state, ensure_ascii=False)[:1000],
        world_language=world.language,
    )

    response = await llm.chat(
        messages=[{"role": "system", "content": system_prompt}],
        tools=TRIGGER_RUNNER_TOOL_SCHEMAS,
        temperature=0.5,
        max_tokens=600,
        purpose="trigger",
        user_id=user_id,
        session_id=session_id,
        db=db,
    )

    # Extract from submit_trigger_result tool call; fall back to JSON parse.
    parsed: Dict[str, Any] = {}
    extracted = False
    for tc in (response.tool_calls or []):
        if tc.get("function", {}).get("name") == "submit_trigger_result":
            args_str = tc.get("function", {}).get("arguments", "{}")
            try:
                parsed = json.loads(args_str) if args_str else {}
                extracted = True
            except json.JSONDecodeError:
                pass
            break
    if not extracted:
        m = re.search(r"\{[\s\S]*\}", response.text or "")
        if m:
            try:
                parsed = json.loads(m.group(0))
            except json.JSONDecodeError:
                pass

    # Apply state patch
    state_patch = parsed.get("state_patch", {}) or {}
    if state_patch:
        new_state = apply_patch(world.state, state_patch)
        schema = world.definition.get("world_schema", {})
        ok, _errors = validate_state(new_state, schema)
        if ok:
            world.state = new_state

    narrative = parsed.get("narrative", "") or ""
    should_notify = bool(parsed.get("should_notify_player", True))

    # Compute next message seq
    seq_result = await db.execute(
        select(Message.seq)
        .where(Message.session_id == session_id)
        .order_by(Message.seq.desc())
        .limit(1)
    )
    row = seq_result.first()
    next_seq = (row[0] + 1) if row else 1

    if should_notify and narrative:
        msg = Message(
            session_id=session_id,
            seq=next_seq,
            role="system",
            kind="narrative_step",
            content=narrative,
            payload={
                "trigger_id": str(trigger.id),
                "triggered_at": trigger.fire_at,
                "outcome": parsed.get("outcome", trigger.description),
                "world_time": world.current_time,
                "player_state": world.state.get("player", {}),
                "options": [],
            },
            is_pinned=True,
            hidden=False,
        )
    else:
        msg = Message(
            session_id=session_id,
            seq=next_seq,
            role="system",
            kind="technical_offscreen",
            content=f"[Trigger fired: {trigger.description}] Outcome: {parsed.get('outcome', '')}",
            payload={
                "trigger_id": str(trigger.id),
                "outcome": parsed.get("outcome", ""),
                "state_patch": state_patch,
            },
            is_pinned=False,
            hidden=True,
        )
    db.add(msg)
    trigger.fired = True
    log.info("trigger_fired", trigger_id=str(trigger.id), session_id=str(session_id))