"""Tests for the Telegram inline command picker (@botname <query>).

Covers the PTB-free logic module ``plugins/platforms/telegram/inline_picker``
(catalog collection, ranking, pagination) and the adapter's
``_handle_inline_query`` (auth gate, personal caching, empty-answer on
deny). The picker exists because the BotCommand menu is capped (60-slot
Hermes default / 100 API max, ~4KB payload) while inline mode is uncapped —
every command and skill must be reachable through it.
"""

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from gateway.config import Platform, PlatformConfig
from plugins.platforms.telegram.inline_picker import (
    PAGE_SIZE,
    build_inline_results,
    collect_inline_catalog,
    filter_catalog,
)


# ---------------------------------------------------------------------------
# Logic module — no PTB required
# ---------------------------------------------------------------------------


class TestFilterCatalog:
    CATALOG = [
        {"name": "help", "description": "Show available commands"},
        {"name": "plan", "description": "Write a markdown implementation plan"},
        {"name": "plugin_tools", "description": "List plugin tools"},
        {"name": "songsee", "description": "Audio spectrograms and planning aids"},
    ]

    def test_empty_term_returns_everything_in_order(self):
        assert filter_catalog(self.CATALOG, "") == self.CATALOG
        assert filter_catalog(self.CATALOG, "   ") == self.CATALOG

    def test_prefix_beats_substring_beats_description(self):
        ranked = filter_catalog(self.CATALOG, "plan")
        names = [i["name"] for i in ranked]
        # prefix match first, then description matches ("...plan" in
        # plugin_tools description? no — songsee mentions planning).
        assert names[0] == "plan"
        assert "songsee" in names  # description hit ranks after name hits

    def test_hyphen_underscore_equivalent(self):
        catalog = [{"name": "gif_search", "description": "Find GIFs"}]
        assert filter_catalog(catalog, "gif-se")[0]["name"] == "gif_search"

    def test_leading_slash_stripped(self):
        assert filter_catalog(self.CATALOG, "/plan")[0]["name"] == "plan"

    def test_no_match_returns_empty(self):
        assert filter_catalog(self.CATALOG, "zzzznope") == []


class TestBuildInlineResults:
    def _fake_catalog(self, n):
        return [
            {"name": f"cmd-{i:03d}", "description": f"desc {i}"} for i in range(n)
        ]

    def test_first_page_and_next_offset(self):
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=self._fake_catalog(PAGE_SIZE + 10),
        ):
            results, next_offset = build_inline_results("", offset="")
        assert len(results) == PAGE_SIZE
        assert next_offset == str(PAGE_SIZE)

    def test_last_page_signals_stop_with_empty_offset(self):
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=self._fake_catalog(PAGE_SIZE + 10),
        ):
            results, next_offset = build_inline_results("", offset=str(PAGE_SIZE))
        assert len(results) == 10
        assert next_offset == ""

    def test_args_after_first_token_carry_into_message_text(self):
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=[{"name": "plan", "description": "Plan mode"}],
        ):
            results, _ = build_inline_results("plan migrate auth to OIDC")
        assert results[0]["message_text"] == "/plan migrate auth to OIDC"
        assert results[0]["title"] == "/plan"

    def test_bare_query_sends_bare_command(self):
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=[{"name": "plan", "description": "Plan mode"}],
        ):
            results, _ = build_inline_results("plan")
        assert results[0]["message_text"] == "/plan"

    def test_garbage_offset_treated_as_zero(self):
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=self._fake_catalog(3),
        ):
            results, _ = build_inline_results("", offset="not-a-number")
        assert len(results) == 3

    def test_result_ids_unique_across_pages(self):
        catalog = self._fake_catalog(PAGE_SIZE * 2)
        with patch(
            "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
            return_value=catalog,
        ):
            page1, off = build_inline_results("", offset="")
            page2, _ = build_inline_results("", offset=off)
        ids = {r["id"] for r in page1} | {r["id"] for r in page2}
        assert len(ids) == PAGE_SIZE * 2


class TestCollectInlineCatalog:
    def test_catalog_is_uncapped_and_includes_all_skills(self, tmp_path, monkeypatch):
        """The whole point: unlike the 60-slot menu, EVERY skill appears."""
        monkeypatch.setenv("HERMES_HOME", str(tmp_path))
        skills = tmp_path / "skills"
        names = [f"filler-{i:02d}" for i in range(70)] + ["zzz-last-skill"]
        for n in names:
            d = skills / n
            d.mkdir(parents=True)
            (d / "SKILL.md").write_text(
                f"---\nname: {n}\ndescription: test skill {n}\n---\n# {n}\n"
            )
        # SKILLS_DIR is resolved at import time — in a full-suite run it
        # points at an earlier test's HERMES_HOME, so pin it (both the
        # scanner in agent.skill_commands and the prefix allowlist in
        # _collect_gateway_skill_entries import it from tools.skills_tool).
        from tools import skills_tool

        monkeypatch.setattr(skills_tool, "SKILLS_DIR", skills)
        catalog = collect_inline_catalog()
        got = {i["name"] for i in catalog}
        # Late-alphabet skill that the capped menu would trim is present.
        assert "zzz_last_skill" in got or "zzz-last-skill" in got
        # All 71 skills present (names are telegram-sanitized).
        assert sum(1 for n in got if n.startswith("filler_")) == 70
        # Core commands present too.
        assert "help" in got and "plan" in got

    def test_no_duplicate_names(self, tmp_path, monkeypatch):
        monkeypatch.setenv("HERMES_HOME", str(tmp_path))
        (tmp_path / "skills").mkdir()
        catalog = collect_inline_catalog()
        names = [i["name"] for i in catalog]
        assert len(names) == len(set(names))


# ---------------------------------------------------------------------------
# Adapter handler — telegram mock from tests/gateway/conftest.py
# ---------------------------------------------------------------------------


def _make_adapter(authorized=True):
    from plugins.platforms.telegram.adapter import TelegramAdapter

    adapter = object.__new__(TelegramAdapter)
    adapter.platform = Platform.TELEGRAM
    adapter.config = PlatformConfig(enabled=True, token="***", extra={})
    adapter._is_callback_user_authorized = MagicMock(return_value=authorized)
    return adapter


def _inline_update(query="", offset="", user_id=42):
    inline_query = SimpleNamespace(
        query=query,
        offset=offset,
        from_user=SimpleNamespace(id=user_id, username="tester"),
        answer=AsyncMock(),
    )
    return SimpleNamespace(inline_query=inline_query)


@pytest.mark.asyncio
async def test_inline_query_authorized_answers_with_articles():
    adapter = _make_adapter(authorized=True)
    update = _inline_update(query="plan")
    with patch(
        "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
        return_value=[{"name": "plan", "description": "Plan mode"}],
    ):
        await adapter._handle_inline_query(update, None)
    update.inline_query.answer.assert_awaited_once()
    args, kwargs = update.inline_query.answer.call_args
    assert len(args[0]) == 1
    assert kwargs["is_personal"] is True
    assert kwargs["next_offset"] == ""


@pytest.mark.asyncio
async def test_inline_query_unauthorized_gets_empty_results():
    adapter = _make_adapter(authorized=False)
    update = _inline_update(query="plan")
    await adapter._handle_inline_query(update, None)
    update.inline_query.answer.assert_awaited_once()
    args, kwargs = update.inline_query.answer.call_args
    assert args[0] == []
    assert kwargs["is_personal"] is True


@pytest.mark.asyncio
async def test_inline_query_missing_user_denied():
    adapter = _make_adapter(authorized=True)
    update = _inline_update(query="plan")
    update.inline_query.from_user = None
    await adapter._handle_inline_query(update, None)
    args, _kwargs = update.inline_query.answer.call_args
    assert args[0] == []


@pytest.mark.asyncio
async def test_inline_query_pagination_offset_passthrough():
    adapter = _make_adapter(authorized=True)
    catalog = [
        {"name": f"cmd-{i:03d}", "description": ""} for i in range(PAGE_SIZE + 5)
    ]
    update = _inline_update(query="", offset=str(PAGE_SIZE))
    with patch(
        "plugins.platforms.telegram.inline_picker.collect_inline_catalog",
        return_value=catalog,
    ):
        await adapter._handle_inline_query(update, None)
    args, kwargs = update.inline_query.answer.call_args
    assert len(args[0]) == 5
    assert kwargs["next_offset"] == ""


@pytest.mark.asyncio
async def test_inline_query_answer_failure_is_swallowed():
    adapter = _make_adapter(authorized=True)
    update = _inline_update(query="plan")
    update.inline_query.answer = AsyncMock(side_effect=RuntimeError("boom"))
    # Must not raise — inline answering is best-effort.
    await adapter._handle_inline_query(update, None)


@pytest.mark.asyncio
async def test_inline_query_none_update_is_noop():
    adapter = _make_adapter(authorized=True)
    await adapter._handle_inline_query(SimpleNamespace(inline_query=None), None)