"""Regression: /footer must dispatch to its handler while an agent is running.

The gateway runner's running-agent block (``gateway/run.py``) routes the
"session-level toggles that are safe to run mid-agent" through a membership
set before the catch-all that rejects everything else with
``"Agent is running — /<cmd> can't run mid-turn"``.

``/footer`` is a pure display toggle: like its sibling ``/verbose`` it only
writes a ``display.*`` config key and returns a status string (see
``_handle_footer_command`` / ``_handle_verbose_command``), and the runner
already ships a dedicated mid-run dispatch branch for it. But the gate set
listed only ``{"yolo", "verbose"}``, so the ``footer`` branch was
unreachable: ``/footer`` fell through to the catch-all and was rejected,
forcing the user to ``/stop`` a running agent just to toggle a footer.

These tests pin that ``/footer`` (and, as a parity guard, ``/verbose``)
reach their handlers mid-run instead of the busy catch-all rejection.

Mirrors the runner-construction pattern of ``test_steer_command.py`` so the
same proven path through ``_handle_message`` reaches the running-agent
command dispatch.
"""
from __future__ import annotations

from datetime import datetime
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock

import pytest

from gateway.config import GatewayConfig, Platform, PlatformConfig
from gateway.platforms.base import MessageEvent
from gateway.session import SessionEntry, SessionSource, build_session_key


def _make_source() -> SessionSource:
    return SessionSource(
        platform=Platform.TELEGRAM,
        user_id="u1",
        chat_id="c1",
        user_name="tester",
        chat_type="dm",
    )


def _make_event(text: str) -> MessageEvent:
    return MessageEvent(
        text=text,
        source=_make_source(),
        message_id="m1",
    )


def _make_runner(session_entry: SessionEntry):
    from gateway.run import GatewayRunner

    runner = object.__new__(GatewayRunner)
    runner.config = GatewayConfig(
        platforms={Platform.TELEGRAM: PlatformConfig(enabled=True, token="***")}
    )
    adapter = MagicMock()
    adapter.send = AsyncMock()
    adapter._pending_messages = {}
    runner.adapters = {Platform.TELEGRAM: adapter}
    runner._voice_mode = {}
    runner.hooks = SimpleNamespace(emit=AsyncMock(), loaded_hooks=False)
    runner.session_store = MagicMock()
    runner.session_store.get_or_create_session.return_value = session_entry
    runner.session_store.load_transcript.return_value = []
    runner.session_store.has_any_sessions.return_value = True
    runner._running_agents = {}
    runner._running_agents_ts = {}
    runner._pending_messages = {}
    runner._pending_approvals = {}
    runner._session_db = MagicMock()
    runner._session_db.get_session_title.return_value = None
    runner._reasoning_config = None
    runner._provider_routing = {}
    runner._fallback_model = None
    runner._show_reasoning = False
    runner._is_user_authorized = lambda _source: True
    runner._set_session_env = lambda _context: None
    runner._should_send_voice_reply = lambda *_args, **_kwargs: False
    runner._send_voice_reply = AsyncMock()
    runner._capture_gateway_honcho_if_configured = lambda *args, **kwargs: None
    runner._emit_gateway_run_progress = AsyncMock()
    return runner, adapter


def _session_entry() -> SessionEntry:
    return SessionEntry(
        session_key=build_session_key(_make_source()),
        session_id="sess-1",
        created_at=datetime.now(),
        updated_at=datetime.now(),
        platform=Platform.TELEGRAM,
        chat_type="dm",
        total_tokens=0,
    )


_BUSY_REJECTION = "can't run"


@pytest.mark.asyncio
async def test_footer_dispatches_to_handler_when_agent_running():
    """/footer mid-run reaches _handle_footer_command, not the busy catch-all."""
    runner, _adapter = _make_runner(_session_entry())
    sk = build_session_key(_make_source())
    runner._running_agents[sk] = MagicMock()

    handler = AsyncMock(return_value="footer toggled")
    runner._handle_footer_command = handler

    result = await runner._handle_message(_make_event("/footer"))

    handler.assert_awaited_once()
    assert result == "footer toggled"
    assert _BUSY_REJECTION not in (result or ""), (
        "/footer hit the busy catch-all instead of dispatching to its handler"
    )


if __name__ == "__main__":  # pragma: no cover
    pytest.main([__file__, "-v"])
