# Generated by oapi-gen. DO NOT EDIT.
from __future__ import annotations

from functools import partial
from typing import Annotated, Literal

from msgspec import Meta, json
from starlette.exceptions import HTTPException
from starlette.requests import Request
from starlette.responses import Response
from starlette.routing import Route

from .._runtime import RequestError as _runtime_RequestError
from .._runtime import bearer_auth as _runtime_bearer_auth
from .._runtime import boolean as _runtime_boolean
from .._runtime import check_json_content_type as _runtime_check_json_content_type
from .._runtime import check_property_counts as _runtime_check_property_counts
from .._runtime import comma_values as _runtime_comma_values
from .._runtime import encode_header as _runtime_encode_header
from .._runtime import error_response as _runtime_error_response
from .._runtime import json_body as _runtime_json_body
from .._runtime import multipart_body as _runtime_multipart_body
from .._runtime import parameter as _runtime_parameter
from .._runtime import upload as _runtime_upload
from .._streams import EventField as _streams_EventField
from .._streams import StreamResponse as _streams_StreamResponse
from .._streams import encode_json_item as _streams_encode_json_item
from .._streams import encode_sse_item as _streams_encode_sse_item
from ..contracts._shared import DeviceSecurity, SecurityHandler, SecurityRejected
from ..contracts.cats import CatsHandler
from ..contracts.cats import ExportCats as _contracts_ExportCats
from ..contracts.cats import ExportCatsNdjson as _contracts_ExportCatsNdjson
from ..contracts.cats import ExportCatsSequence as _contracts_ExportCatsSequence
from ..contracts.cats import WatchCats as _contracts_WatchCats
from ..models import Cat as _models_Cat

_encoder = json.Encoder()
_watch_cats__parameter_last_event_id = str | None
json.Decoder(_watch_cats__parameter_last_event_id)
_watch_cats__200_event_fields = (
    _streams_EventField("data", True, json.Decoder(_models_Cat), json.Decoder(str), True, None),
    _streams_EventField(
        "event",
        True,
        json.Decoder(Literal["cat.updated"]),
        json.Decoder(Literal["cat.updated"]),
        False,
        None,
    ),
    _streams_EventField("id", False, json.Decoder(str), json.Decoder(str), False, None),
    _streams_EventField(
        "retry",
        False,
        json.Decoder(Annotated[int, Meta(ge=0)]),
        json.Decoder(Annotated[int, Meta(ge=0)]),
        False,
        None,
    ),
)
_export_cats__200_decoder = json.Decoder(_models_Cat)
_export_cats_ndjson__200_decoder = json.Decoder(_models_Cat)
_export_cats_sequence__200_decoder = json.Decoder(_models_Cat)


def create_routes(
    handler: CatsHandler, *, security: SecurityHandler, prefix: str = ""
) -> dict[tuple[str, str], Route]:
    __oapi_handler = handler
    __oapi_security = security
    __oapi_routes: dict[tuple[str, str], Route] = {}

    async def __oapi_endpoint_watch_cats(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_credential_device = _runtime_bearer_auth(__oapi_http.headers.get("authorization"))
        if not __oapi_security_satisfied and __oapi_credential_device is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_device(
                    __oapi_alternative_context,
                    "watchCats",
                    DeviceSecurity(
                        token=__oapi_credential_device.credentials,
                        scopes=("cats:read",),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_parameter_last_event_id = _runtime_parameter(
                __oapi_http.headers.get("Last-Event-ID"),
                _watch_cats__parameter_last_event_id,
                ("header", "Last-Event-ID"),
                required=False,
                default=None,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_WatchCats.Request(
            last_event_id=__oapi_parameter_last_event_id, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handler.watch_cats(__oapi_request)
        except _contracts_WatchCats.Forbidden as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("watchCats error responses must be raised")
        if isinstance(__oapi_result, _contracts_WatchCats.Ok):
            return _streams_StreamResponse(
                __oapi_result.body,
                encode=partial(
                    _streams_encode_sse_item,
                    event_type=_contracts_WatchCats.Event,
                    fields=_watch_cats__200_event_fields,
                    checked=True,
                ),
                status_code=200,
                media_type="text/event-stream",
            )
        if isinstance(__oapi_result, _contracts_WatchCats.Forbidden):
            return Response(status_code=403)
        raise TypeError("watchCats returned an unsupported response variant")

    __oapi_route_watch_cats = Route(
        prefix + "/cats/events", __oapi_endpoint_watch_cats, methods=["GET"], name="watchCats"
    )
    __oapi_route_watch_cats.methods = {"GET"}
    __oapi_routes[("/cats/events", "get")] = __oapi_route_watch_cats

    async def __oapi_endpoint_export_cats(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_ExportCats.Request()
        __oapi_result = await __oapi_handler.export_cats(__oapi_request)
        if isinstance(__oapi_result, _contracts_ExportCats.Ok):
            return _streams_StreamResponse(
                __oapi_result.body,
                encode=partial(
                    _streams_encode_json_item,
                    decoder=_export_cats__200_decoder,
                    media_type="application/jsonl",
                    checked=True,
                ),
                status_code=200,
                media_type="application/jsonl",
            )
        raise TypeError("exportCats returned an unsupported response variant")

    __oapi_route_export_cats = Route(
        prefix + "/cats/jsonl", __oapi_endpoint_export_cats, methods=["GET"], name="exportCats"
    )
    __oapi_route_export_cats.methods = {"GET"}
    __oapi_routes[("/cats/jsonl", "get")] = __oapi_route_export_cats

    async def __oapi_endpoint_export_cats_ndjson(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_ExportCatsNdjson.Request()
        __oapi_result = await __oapi_handler.export_cats_ndjson(__oapi_request)
        if isinstance(__oapi_result, _contracts_ExportCatsNdjson.Ok):
            return _streams_StreamResponse(
                __oapi_result.body,
                encode=partial(
                    _streams_encode_json_item,
                    decoder=_export_cats_ndjson__200_decoder,
                    media_type="application/x-ndjson",
                    checked=True,
                ),
                status_code=200,
                media_type="application/x-ndjson",
            )
        raise TypeError("exportCatsNdjson returned an unsupported response variant")

    __oapi_route_export_cats_ndjson = Route(
        prefix + "/cats/ndjson",
        __oapi_endpoint_export_cats_ndjson,
        methods=["GET"],
        name="exportCatsNdjson",
    )
    __oapi_route_export_cats_ndjson.methods = {"GET"}
    __oapi_routes[("/cats/ndjson", "get")] = __oapi_route_export_cats_ndjson

    async def __oapi_endpoint_export_cats_sequence(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_ExportCatsSequence.Request()
        __oapi_result = await __oapi_handler.export_cats_sequence(__oapi_request)
        if isinstance(__oapi_result, _contracts_ExportCatsSequence.Ok):
            return _streams_StreamResponse(
                __oapi_result.body,
                encode=partial(
                    _streams_encode_json_item,
                    decoder=_export_cats_sequence__200_decoder,
                    media_type="application/json-seq",
                    checked=True,
                ),
                status_code=200,
                media_type="application/json-seq",
            )
        raise TypeError("exportCatsSequence returned an unsupported response variant")

    __oapi_route_export_cats_sequence = Route(
        prefix + "/cats/sequence",
        __oapi_endpoint_export_cats_sequence,
        methods=["GET"],
        name="exportCatsSequence",
    )
    __oapi_route_export_cats_sequence.methods = {"GET"}
    __oapi_routes[("/cats/sequence", "get")] = __oapi_route_export_cats_sequence
    return __oapi_routes
