# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/in-what-scenarios-must-an-instance-reject-a2a-v1-0-agent-card-discovery-results-before-task-negotiation.md
# Remnant Warrant:    https://corpusfetch.com/c/in-what-scenarios-must-an-instance-reject-a2a-v1-0-agent-card-discovery-results-before-task-negotiation.warrant.json
# Markdown SHA-256:   31edba44cbf5dc289fbe3c98d5b885c21c564287aeb8c235f41e742915fbea98
# Code AST SHA-256:   ad1bcb2f5111332a28589cae593abef17bb39a5a95bb8a72e6ab2c7c95687a95
# Verified Classes:   CardRejectedError, AgentCard, IntendedTask
# Defensive Guards:   6 fail-closed invariants (zero external deps)

from __future__ import annotations

from dataclasses import dataclass
from urllib.parse import urlparse


class CardRejectedError(RuntimeError):
    """Raised when a discovered A2A v1.0 Agent Card is not negotiation-valid
    for the pending task, even though it passed schema validation."""


@dataclass(frozen=True)
class AgentCard:
    url: str
    version: str
    streaming: bool
    default_input_modes: tuple[str, ...]
    default_output_modes: tuple[str, ...]


@dataclass(frozen=True)
class IntendedTask:
    method: str  # "tasks/send" or "tasks/sendSubscribe"
    input_media_type: str


def _origin(url: str) -> tuple[str, str]:
    p = urlparse(url)
    return (p.scheme, p.netloc)


def _media_type_matches(advertised: str, actual: str) -> bool:
    # RFC 9110 §8.3.1: match on type/subtype, ignore parameters.
    return advertised.split(";", 1)[0].strip().lower() == actual.split(";", 1)[0].strip().lower()


def validate_card_for_task(
    card: AgentCard,
    *,
    delivery_origin: tuple[str, str],
    task: IntendedTask,
    allowlisted_origins: frozenset[tuple[str, str]] = frozenset(),
) -> None:
    card_origin = _origin(card.url)
    if card_origin[0] != "https":
        raise CardRejectedError(
            f"card advertises non-TLS url {card.url!r}; plaintext negotiation forbidden"
        )
    if card_origin != delivery_origin and card_origin not in allowlisted_origins:
        raise CardRejectedError(
            f"card url origin {card_origin!r} differs from delivery origin "
            f"{delivery_origin!r} and is not allowlisted; possible url drift"
        )
    if not card.version.startswith("1."):
        raise CardRejectedError(
            f"card version {card.version!r} is not A2A v1.x; version-skew at discovery"
        )
    if task.method == "tasks/sendSubscribe" and not card.streaming:
        raise CardRejectedError(
            "tasks/sendSubscribe requested but card.capabilities.streaming is false"
        )
    if not any(_media_type_matches(m, task.input_media_type) for m in card.default_input_modes):
        raise CardRejectedError(
            f"input media type {task.input_media_type!r} not in defaultInputModes "
            f"{card.default_input_modes!r}"
        )
    if not card.default_output_modes:
        raise CardRejectedError("card advertises no defaultOutputModes; artifact exchange undefined")


def negotiate(card: AgentCard, *, delivery_origin: tuple[str, str], task: IntendedTask) -> str:
    validate_card_for_task(card, delivery_origin=delivery_origin, task=task)
    # Only reached when the card is negotiation-valid for this task.
    return f"POST {card.url} method={task.method}"
