"""Parser-only and lightweight routing tests for send_message targets.

These stay separate from ``test_send_message_tool.py`` because that module
skips wholesale when optional Telegram dependencies are not installed.
"""

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

from gateway.config import Platform
from tools.send_message_tool import _parse_target_ref, _send_to_platform, send_message_tool


def _run_async_immediately(coro):
    return asyncio.run(coro)


def test_buzz_uuid_target_is_explicit() -> None:
    channel_id = "31b543d5-80d4-4df5-8a5c-cefca1a58fdd"

    assert _parse_target_ref("buzz", channel_id) == (channel_id, None, True)


def test_live_buzz_media_delivers_every_file_with_reply_metadata(tmp_path) -> None:
    from gateway.platforms.base import SendResult

    platform = Platform("buzz")
    first = tmp_path / "first.txt"
    second = tmp_path / "second.pdf"
    first.write_text("first", encoding="utf-8")
    second.write_text("second", encoding="utf-8")
    calls = []

    class Adapter:
        async def send(self, *, chat_id, content, metadata=None):
            calls.append(("text", content, metadata))
            return SendResult(success=True, message_id="evt-text")

        async def send_document(self, chat_id, file_path, **kwargs):
            calls.append(("document", file_path, kwargs))
            return SendResult(success=True, message_id=f"evt-{len(calls)}")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "attached files",
                thread_id="reply-root",
                media_files=[(str(first), False), (str(second), False)],
            )
        )

    assert result["success"] is True
    assert result["media_delivered"] is True
    assert calls == [
        ("text", "attached files", {"thread_id": "reply-root"}),
        ("document", str(first), {"caption": None, "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}}),
        ("document", str(second), {"caption": None, "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}}),
    ]


def test_live_buzz_single_image_uses_caption_without_duplicate_text(tmp_path) -> None:
    from gateway.platforms.base import SendResult

    platform = Platform("buzz")
    image = tmp_path / "shot.png"
    image.write_bytes(b"png")
    calls = []

    class Adapter:
        async def send(self, **kwargs):
            calls.append(("text", kwargs))
            return SendResult(success=True, message_id="unexpected")

        async def send_image_file(self, chat_id, image_path, **kwargs):
            calls.append(("image", image_path, kwargs))
            return SendResult(success=True, message_id="evt-image")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "screenshot caption",
                thread_id="reply-root",
                media_files=[(str(image), False)],
            )
        )

    assert result == {
        "success": True,
        "message_id": "evt-image",
        "media_delivered": True,
    }
    assert calls == [
        ("image", str(image), {"caption": "screenshot caption", "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}})
    ]


def test_live_buzz_media_failure_is_explicit_not_omitted(tmp_path) -> None:
    from gateway.platforms.base import SendResult

    platform = Platform("buzz")
    first = tmp_path / "first.txt"
    second = tmp_path / "second.txt"
    first.write_text("first", encoding="utf-8")
    second.write_text("second", encoding="utf-8")
    media_calls = []

    class Adapter:
        async def send(self, **kwargs):
            return SendResult(success=True, message_id="evt-text")

        async def send_document(self, chat_id, file_path, **kwargs):
            media_calls.append(file_path)
            if file_path == str(second):
                return SendResult(success=False, error="relay rejected upload")
            return SendResult(success=True, message_id="evt-first")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "attached files",
                media_files=[(str(first), False), (str(second), False)],
            )
        )

    assert media_calls == [str(first), str(second)]
    assert "relay rejected upload" in result["error"]
    assert "media_delivered" not in result


def test_live_buzz_media_only_send_reaches_adapter(tmp_path) -> None:
    from gateway.platforms.base import SendResult

    platform = Platform("buzz")
    document = tmp_path / "report.txt"
    document.write_text("report", encoding="utf-8")
    media_calls = []

    class Adapter:
        async def send(self, **kwargs):
            raise AssertionError("media-only send must not emit an empty text message")

        async def send_document(self, chat_id, file_path, **kwargs):
            media_calls.append((chat_id, file_path, kwargs))
            return SendResult(success=True, message_id="evt-document")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "",
                media_files=[(str(document), False)],
            )
        )

    assert result == {
        "success": True,
        "message_id": "evt-document",
        "media_delivered": True,
    }
    assert len(media_calls) == 1
    assert media_calls[0][1] == str(document)


def test_live_buzz_media_exception_reports_partial_delivery(tmp_path) -> None:
    from gateway.platforms.base import SendResult

    platform = Platform("buzz")
    first = tmp_path / "first.txt"
    second = tmp_path / "second.txt"
    first.write_text("first", encoding="utf-8")
    second.write_text("second", encoding="utf-8")

    class Adapter:
        async def send(self, **kwargs):
            return SendResult(success=True, message_id="evt-text")

        async def send_document(self, chat_id, file_path, **kwargs):
            if file_path == str(second):
                raise RuntimeError("relay transport failed")
            return SendResult(success=True, message_id="evt-first")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "attached files",
                media_files=[(str(first), False), (str(second), False)],
            )
        )

    assert "after 1/2 files" in result["error"]
    assert "relay transport failed" in result["error"]
    assert "media_delivered" not in result


def test_live_adapter_inherited_media_fallback_is_not_claimed_as_delivery(tmp_path) -> None:
    from gateway.platforms.base import BasePlatformAdapter, SendResult

    platform = Platform("buzz")
    document = tmp_path / "report.txt"
    document.write_text("report", encoding="utf-8")

    class Adapter:
        name = "Fallback-only"
        send_document = BasePlatformAdapter.send_document

        async def send(self, **kwargs):
            return SendResult(success=True, message_id="warning-text-only")

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "attached",
                media_files=[(str(document), False)],
            )
        )

    assert "does not implement native document delivery" in result["error"]
    assert "media_delivered" not in result


def test_live_buzz_adapter_exception_is_bounded() -> None:
    platform = Platform("buzz")

    class Adapter:
        async def send(self, **kwargs):
            raise RuntimeError("x" * 100_000)

    runner = SimpleNamespace(adapters={platform: Adapter()})
    with patch("gateway.run._gateway_runner_ref", return_value=runner):
        result = asyncio.run(
            _send_to_platform(
                platform,
                SimpleNamespace(enabled=True, token=None, extra={}),
                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
                "hello",
            )
        )

    assert result["error"].startswith("Plugin platform send failed: ")
    assert len(result["error"]) <= 1024


def test_send_message_routes_buzz_uuid_without_home_fallback() -> None:
    buzz_platform = Platform("buzz")
    buzz_cfg = SimpleNamespace(enabled=True, token=None, extra={})
    config = SimpleNamespace(
        platforms={buzz_platform: buzz_cfg},
        get_home_channel=lambda _platform: SimpleNamespace(chat_id="home-channel"),
    )
    channel_id = "31b543d5-80d4-4df5-8a5c-cefca1a58fdd"

    with patch("gateway.config.load_gateway_config", return_value=config), \
         patch("tools.interrupt.is_interrupted", return_value=False), \
         patch("gateway.channel_directory.resolve_channel_name", side_effect=AssertionError("raw UUID should not resolve via directory")), \
         patch("model_tools._run_async", side_effect=_run_async_immediately), \
         patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
         patch("gateway.mirror.mirror_to_session", return_value=True):
        result = json.loads(
            send_message_tool(
                {
                    "action": "send",
                    "target": f"buzz:{channel_id}",
                    "message": "hello group",
                }
            )
        )

    assert result["success"] is True
    assert "note" not in result
    send_mock.assert_awaited_once_with(
        buzz_platform,
        buzz_cfg,
        channel_id,
        "hello group",
        thread_id=None,
        media_files=[],
        force_document=False,
    )


def test_photon_e164_target_is_explicit() -> None:
    chat_id, thread_id, is_explicit = _parse_target_ref("photon", "+15551234567")

    assert chat_id == "+15551234567"
    assert thread_id is None
    assert is_explicit is True


def test_e164_target_still_requires_phone_platform() -> None:
    assert _parse_target_ref("matrix", "+15551234567")[2] is False


def test_send_message_routes_whatsapp_group_jid_without_home_fallback() -> None:
    whatsapp_cfg = SimpleNamespace(enabled=True, token=None, extra={"api_url": "http://bridge"})
    config = SimpleNamespace(
        platforms={Platform.WHATSAPP: whatsapp_cfg},
        get_home_channel=lambda _platform: SimpleNamespace(chat_id="15551234567@s.whatsapp.net"),
    )

    with patch("gateway.config.load_gateway_config", return_value=config), \
         patch("tools.interrupt.is_interrupted", return_value=False), \
         patch("gateway.channel_directory.resolve_channel_name", side_effect=AssertionError("raw JID should not resolve via directory")), \
         patch("model_tools._run_async", side_effect=_run_async_immediately), \
         patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
         patch("gateway.mirror.mirror_to_session", return_value=True):
        result = json.loads(
            send_message_tool(
                {
                    "action": "send",
                    "target": "whatsapp:120363408391911677@g.us",
                    "message": "hello group",
                }
            )
        )

    assert result["success"] is True
    assert "note" not in result
    send_mock.assert_awaited_once_with(
        Platform.WHATSAPP,
        whatsapp_cfg,
        "120363408391911677@g.us",
        "hello group",
        thread_id=None,
        media_files=[],
        force_document=False,
    )


def test_resolved_opaque_plugin_target_uses_directory_id() -> None:
    from gateway.platform_registry import PlatformEntry, platform_registry

    platform_name = "opaque-resolved-test"
    entry = PlatformEntry(
        name=platform_name,
        label="Opaque resolved test",
        adapter_factory=lambda cfg: None,
        check_fn=lambda: True,
    )
    platform_registry.register(entry)
    platform = Platform(platform_name)
    pconfig = SimpleNamespace(enabled=True, token=None, extra={})
    config = SimpleNamespace(
        platforms={platform: pconfig},
        get_home_channel=lambda _platform: None,
    )
    try:
        with patch("gateway.config.load_gateway_config", return_value=config), \
             patch("tools.interrupt.is_interrupted", return_value=False), \
             patch(
                 "gateway.channel_directory.resolve_channel_name",
                 return_value="opaque:directory-id",
             ), \
             patch("model_tools._run_async", side_effect=_run_async_immediately), \
             patch(
                 "tools.send_message_tool._send_to_platform",
                 new=AsyncMock(return_value={"success": True}),
             ) as send_mock, \
             patch("gateway.mirror.mirror_to_session", return_value=True):
            result = json.loads(
                send_message_tool(
                    {
                        "action": "send",
                        "target": f"{platform_name}:Friendly name",
                        "message": "hello",
                    }
                )
            )
    finally:
        platform_registry.unregister(platform_name)

    assert result["success"] is True
    send_mock.assert_awaited_once_with(
        platform,
        pconfig,
        "opaque:directory-id",
        "hello",
        thread_id=None,
        media_files=[],
        force_document=False,
    )


def test_unresolved_plugin_target_requires_explicit_parser() -> None:
    from gateway.platform_registry import PlatformEntry, platform_registry

    platform_name = "opaque-verbatim-test"
    entry = PlatformEntry(
        name=platform_name,
        label="Opaque verbatim test",
        adapter_factory=lambda cfg: None,
        check_fn=lambda: True,
    )
    platform_registry.register(entry)
    platform = Platform(platform_name)
    # Simulate a fresh `hermes send` process: the dynamic Platform member
    # is known from config, but plugin discovery has not registered its
    # adapter entry yet.
    platform_registry.unregister(platform_name)
    pconfig = SimpleNamespace(enabled=True, token=None, extra={})
    config = SimpleNamespace(
        platforms={platform: pconfig},
        get_home_channel=lambda _platform: None,
    )
    try:
        with patch("gateway.config.load_gateway_config", return_value=config), \
             patch("tools.interrupt.is_interrupted", return_value=False), \
             patch(
                 "gateway.channel_directory.resolve_channel_name",
                 return_value=None,
             ), \
             patch(
                 "hermes_cli.plugins.discover_plugins",
                 side_effect=lambda: platform_registry.register(entry),
             ) as discover_mock, \
             patch("model_tools._run_async", side_effect=_run_async_immediately), \
             patch(
                 "tools.send_message_tool._send_to_platform",
                 new=AsyncMock(return_value={"success": True}),
             ) as send_mock, \
             patch("gateway.mirror.mirror_to_session", return_value=True):
            result = json.loads(
                send_message_tool(
                    {
                        "action": "send",
                        "target": f"{platform_name}:dm:panyaozhen",
                        "message": "hello",
                    }
                )
            )
    finally:
        platform_registry.unregister(platform_name)

    assert result == {
        "error": f"Could not resolve 'dm:panyaozhen' on {platform_name}. "
        "The plugin parser did not recognize it and no channel-directory entry matched."
    }
    discover_mock.assert_called_once_with()
    send_mock.assert_not_awaited()


def test_unresolved_builtin_target_keeps_directory_error() -> None:
    telegram_cfg = SimpleNamespace(enabled=True, token="***", extra={})
    config = SimpleNamespace(
        platforms={Platform.TELEGRAM: telegram_cfg},
        get_home_channel=lambda _platform: None,
    )

    with patch("gateway.config.load_gateway_config", return_value=config), \
         patch("gateway.channel_directory.resolve_channel_name", return_value=None), \
         patch(
             "tools.send_message_tool._send_to_platform",
             new=AsyncMock(return_value={"success": True}),
         ) as send_mock:
        result = json.loads(
            send_message_tool(
                {
                    "action": "send",
                    "target": "telegram:missing-room",
                    "message": "hello",
                }
            )
        )

    assert result == {
        "error": "Could not resolve 'missing-room' on telegram. "
        "Use send_message(action='list') to see available targets."
    }
    send_mock.assert_not_awaited()



def test_unresolved_builtin_target_passes_through_when_requested() -> None:
    """Cron and react keep the old pass-through behavior for unresolved
    built-in targets: with no model in the loop to react to an error, the
    raw id must reach the adapter, as it did before resolve_send_target
    took over these callers."""
    from tools.send_message_tool import resolve_send_target

    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
        chat_id, thread_id, error = resolve_send_target(
            "telegram", "ops-room", pass_unresolved_references=True
        )

    assert error is None
    assert chat_id == "ops-room"
    assert thread_id is None


def test_unresolved_builtin_target_still_errors_for_the_model_tool() -> None:
    """The model-facing default stays strict: unresolved targets error with a hint."""
    from tools.send_message_tool import resolve_send_target

    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
        chat_id, _thread_id, error = resolve_send_target("telegram", "ops-room")

    assert chat_id is None
    assert error is not None


def test_photon_group_guid_passes_through_when_requested() -> None:
    """The reported regression case: a photon group GUID matches no parser
    pattern (only DM GUIDs have an explicit rule) and no directory entry.
    Photon registers as a parser-less plugin platform, so the pass-through
    applies once platforms are prepared."""
    from tools.send_message_tool import (
        prepare_send_message_platforms,
        resolve_send_target,
    )

    prepare_send_message_platforms()
    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
        chat_id, thread_id, error = resolve_send_target(
            "photon", "iMessage;+;chat527148912345", pass_unresolved_references=True
        )

    assert error is None
    assert chat_id == "iMessage;+;chat527148912345"
    assert thread_id is None


def test_parserless_plugin_target_passes_through_when_requested() -> None:
    """A plugin platform that declares no parser has no explicit syntax at
    all, so passing the raw id through is the only way cron can target it."""
    from gateway.platform_registry import PlatformEntry, platform_registry
    from tools.send_message_tool import resolve_send_target

    platform_name = "opaque-cron-fallback-test"
    entry = PlatformEntry(
        name=platform_name,
        label="Opaque cron fallback test",
        adapter_factory=lambda cfg: None,
        check_fn=lambda: True,
    )
    platform_registry.register(entry)
    try:
        with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
            chat_id, thread_id, error = resolve_send_target(
                platform_name, "dm:panyaozhen", pass_unresolved_references=True
            )
    finally:
        platform_registry.unregister(platform_name)

    assert error is None
    assert chat_id == "dm:panyaozhen"
    assert thread_id is None


def test_plugin_parser_stays_authoritative_despite_fallback() -> None:
    """A plugin that DOES declare a parser stays strict for every caller:
    its parser is the authority on native syntax, so an unrecognized
    target errors even with pass_unresolved_references."""
    from gateway.platform_registry import PlatformEntry, platform_registry
    from tools.send_message_tool import resolve_send_target

    platform_name = "opaque-parser-strict-test"
    entry = PlatformEntry(
        name=platform_name,
        label="Opaque parser strict test",
        adapter_factory=lambda cfg: None,
        check_fn=lambda: True,
        parse_target_ref_fn=lambda ref: None,
    )
    platform_registry.register(entry)
    try:
        with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
            chat_id, _thread_id, error = resolve_send_target(
                platform_name, "dm:panyaozhen", pass_unresolved_references=True
            )
    finally:
        platform_registry.unregister(platform_name)

    assert chat_id is None
    assert error is not None