"""Codex Responses recovery rungs: stale encrypted-reasoning strip and the replay verdict reset."""
from __future__ import annotations

import logging
from typing import Any

from agent.turn_retry_state import TurnRetryState

logger = logging.getLogger(__name__)


def _is_codex_token_expired(agent: Any, api_error: Exception) -> bool:
    """401 ``token_expired`` from the Codex backend (#88510). It rejects a stale replayed
    ``encrypted_content`` blob with this auth signature, so a persisted session loops on "sign
    in again" while a fresh session on the same bearer works. The caller treats it like
    ``invalid_encrypted_content`` — but only while cached reasoning items remain to strip."""
    if getattr(api_error, "status_code", None) != 401:
        return False
    reason = agent._extract_api_error_context(api_error).get("reason")
    return isinstance(reason, str) and reason.strip().lower() == "token_expired"


def reset_codex_reasoning_replay(agent: Any) -> None:
    """The replay verdict belongs to the route that earned it: a ``/model`` switch, fallback
    activation or primary restore starts the new route with replay on (#61552)."""
    agent._codex_reasoning_replay_enabled = True
    agent._codex_reasoning_replay_rejected = False


def _recover_stale_codex_reasoning(
    agent: Any, _retry: TurnRetryState, messages: list[dict[str, Any]], api_messages: Any,
) -> bool:
    """Stale ``codex_reasoning_items`` blob rejected by the provider: strip cached items (mutates
    persisted ``messages``) and retry once. The first rung drops only the replayed blobs not stamped by
    exactly this endpoint+model (it consumes its own precondition, so it cannot loop); a repeat goes on
    to strip every item. The first full strip keeps replay on, since blobs the
    route mints from now on are sealed with its current key; a repeat rejection means the route
    cannot round-trip its own blobs, so replay is disabled for the session."""
    if (
        _retry.invalid_encrypted_content_retry_attempted
        or agent.api_mode != "codex_responses"
        or not bool(getattr(agent, "_codex_reasoning_replay_enabled", True))
        or not any(
            isinstance(_m, dict)
            and _m.get("role") == "assistant"
            and isinstance(_m.get("codex_reasoning_items"), list)
            and _m.get("codex_reasoning_items")
            for _m in messages
        )
    ):
        return False
    from agent.turn_recovery import _vlines  # facade owns the verbose printer; late import breaks the cycle

    transport = agent._get_transport()
    if transport is not None and (removed := transport.drop_unverified_replay(messages, api_messages)):
        _vlines(agent, f"⚠️  Encrypted reasoning replay was rejected — dropped {removed} item(s) minted elsewhere, retrying...")
        return True
    _retry.invalid_encrypted_content_retry_attempted = True
    keep_replay = not getattr(agent, "_codex_reasoning_replay_rejected", False)
    agent._codex_reasoning_replay_rejected = True
    replay_stats = agent._disable_codex_reasoning_replay(messages, keep_replay=keep_replay)
    # The retry is rebuilt from the request copy; with replay kept on it would resend the stale blob.
    for _m in api_messages if isinstance(api_messages, list) else []:
        if isinstance(_m, dict):
            _m.pop("codex_reasoning_items", None)
    action = "stripped stale" if keep_replay else "disabled replay for this session and stripped"
    _vlines(
        agent,
        f"⚠️  Encrypted reasoning replay was rejected by the provider — "
        f"{action} {replay_stats['items']} item(s) from {replay_stats['messages']} message(s), retrying...",
    )
    logger.warning(
        "%sInvalid encrypted reasoning recovery: %s %d items from %d messages",
        agent.log_prefix, action, replay_stats["items"], replay_stats["messages"],
    )
    return True