from __future__ import annotations

import pytest
from mcp.types import PromptReference

pytestmark = pytest.mark.smoke

EXPECTED_PROMPTS = {
    "authoring",
    "greenfield-architecture",
    "jsfiddle-page-layout",
    "mcp-consumer-repo-shim",
    "nicegui-component-extraction",
    "pytest-fill-scaffold",
    "pytest-scaffold",
}


class TestMcpPromptSurface:
    """Covers smoke-level MCP prompt discovery and retrieval paths."""

    class TestServerMetadata:
        """Covers client-facing identity and completion capabilities."""

        @pytest.mark.asyncio
        async def test_advertises_instructions_and_completions(self, mcp_session_factory) -> None:
            """Ensures VS Code receives server guidance and completion support."""
            async with mcp_session_factory(initialize=False) as mcp_session:
                result = await mcp_session.initialize()

            assert result.instructions is not None
            assert "skill://<name>/SKILL.md" in result.instructions
            assert result.server_info.icons
            assert result.server_info.icons[0].src.startswith("data:image/svg+xml;base64,")
            assert result.capabilities.completions is not None

    class TestPromptDiscovery:
        """Covers MCP prompts/list behavior using native prompt objects."""

        @pytest.mark.asyncio
        async def test_lists_prompt_objects(self, mcp_session_factory) -> None:
            """Ensures prompts/list returns native prompt objects with stable names."""
            async with mcp_session_factory() as mcp_session:
                result = await mcp_session.list_prompts()

            assert {prompt.name for prompt in result.prompts} == EXPECTED_PROMPTS
            assert all(prompt.description for prompt in result.prompts)
            assert all(prompt.title for prompt in result.prompts)

        @pytest.mark.asyncio
        async def test_completes_authored_prompt_choices(self, mcp_session_factory) -> None:
            """Ensures finite prompt choices are available as IDE-style suggestions."""
            async with mcp_session_factory() as mcp_session:
                result = await mcp_session.complete(
                    PromptReference(type="ref/prompt", name="authoring"),
                    {"name": "artifact_type", "value": "pr"},
                )

            assert result.completion.values == ["prompt"]

    class TestPromptResolution:
        """Covers MCP prompts/get behavior using native request and response objects."""

        @pytest.mark.asyncio
        async def test_gets_prompt_as_native_object(self, mcp_session_factory) -> None:
            """Ensures prompts/get resolves a listed prompt into structured message objects."""
            async with mcp_session_factory() as mcp_session:
                resolved_prompt = await mcp_session.get_prompt(
                    name="authoring",
                    arguments={
                        "artifact_type": "skill",
                        "artifact_id": "demo-skill",
                        "goal": "Demonstrate native prompt rendering.",
                    },
                )

            assert resolved_prompt.messages
            assert all(message.content for message in resolved_prompt.messages)
            assert "`artifact_id`: demo-skill" in resolved_prompt.messages[0].content.text