import pytest

from agentci.integrations.opencode.readiness import api_contract_ready, models_ready


def test_api_contract_requires_session_message_and_abort_routes() -> None:
    valid = {
        "paths": {
            "/global/health": {"get": {}},
            "/provider": {"get": {}},
            "/session": {"post": {}},
            "/session/{sessionID}/message": {"post": {}},
            "/session/{sessionID}/abort": {"post": {}},
        }
    }

    assert api_contract_ready(valid)
    del valid["paths"]["/session/{sessionID}/abort"]
    assert not api_contract_ready(valid)


@pytest.mark.parametrize(
    "document",
    [
        None,
        {},
        {"paths": []},
        {
            "paths": {
                "/global/health": None,
                "/provider": {"get": {}},
                "/session": {"post": {}},
            }
        },
    ],
)
def test_api_contract_rejects_malformed_documents(document: object) -> None:
    assert not api_contract_ready(document)


def provider_payload(
    *,
    connected: object = None,
    status: str = "active",
    toolcall: object = True,
    variants: object = None,
) -> dict[str, object]:
    selected_connected = ["openai"] if connected is None else connected
    selected_variants = {"high": {}} if variants is None else variants
    return {
        "connected": selected_connected,
        "all": [
            {
                "id": "openai",
                "models": {
                    "model": {
                        "status": status,
                        "capabilities": {"toolcall": toolcall},
                        "variants": selected_variants,
                    }
                },
            }
        ],
    }


@pytest.mark.parametrize(
    ("payload", "requirement", "expected"),
    [
        (provider_payload(), ("openai", "model", "high"), True),
        (provider_payload(), ("openai", "model", None), True),
        (provider_payload(connected=["anthropic"]), ("openai", "model", "high"), False),
        (provider_payload(status="deprecated"), ("openai", "model", "high"), False),
        (provider_payload(toolcall=False), ("openai", "model", "high"), False),
        (provider_payload(variants={}), ("openai", "model", "high"), False),
        (provider_payload(), ("openai", "missing", "high"), False),
    ],
)
def test_model_readiness_matrix(
    payload: object, requirement: tuple[str, str, str | None], expected: bool
) -> None:
    assert models_ready(payload, {requirement}) is expected


@pytest.mark.parametrize(
    "payload",
    [
        None,
        {},
        {"connected": ["openai"], "all": None},
        {"connected": ["openai"], "all": [{"id": [], "models": {}}]},
        {
            "connected": ["openai"],
            "all": [
                {
                    "id": "openai",
                    "models": {
                        "model": {
                            "status": "active",
                            "capabilities": None,
                            "variants": {"high": {}},
                        }
                    },
                }
            ],
        },
        {
            "connected": ["openai"],
            "all": [
                {
                    "id": "openai",
                    "models": {
                        "model": {
                            "status": "active",
                            "capabilities": {"toolcall": True},
                            "variants": None,
                        }
                    },
                }
            ],
        },
    ],
)
def test_model_readiness_rejects_malformed_payloads(payload: object) -> None:
    assert not models_ready(payload, {("openai", "model", "high")})


def test_model_readiness_requires_all_configured_models() -> None:
    payload = {
        "connected": ["openai"],
        "all": [
            {
                "id": "openai",
                "models": {
                    "model": {
                        "status": "active",
                        "capabilities": {"toolcall": True},
                        "variants": {"high": {}},
                    }
                },
            }
        ],
    }

    assert not models_ready(
        payload,
        {
            ("openai", "model", "high"),
            ("openai", "other", None),
        },
    )