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

from msgspec import convert, json, to_builtins
from starlette.datastructures import MutableHeaders
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 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 ..contracts._shared import BearerAuthSecurity
from ..contracts._shared import Cookie as _contracts_Cookie
from ..contracts._shared import SecurityHandler, SecurityRejected
from ..contracts.auth import AuthHandler
from ..contracts.auth import GetCurrentUser as _contracts_GetCurrentUser
from ..contracts.auth import Login as _contracts_Login
from ..contracts.auth import Logout as _contracts_Logout
from ..contracts.auth import RefreshToken as _contracts_RefreshToken
from ..contracts.auth import RequestPasswordReset as _contracts_RequestPasswordReset
from ..contracts.auth import ResetPassword as _contracts_ResetPassword
from ..contracts.auth import UpdatePassword as _contracts_UpdatePassword
from ..models import AuthSuccessResponse as _models_AuthSuccessResponse
from ..models import HttpValidationError as _models_HttpValidationError
from ..models import LoginRequest as _models_LoginRequest
from ..models import MessageResponse as _models_MessageResponse
from ..models import PasswordResetConfirmRequest as _models_PasswordResetConfirmRequest
from ..models import PasswordResetRequest as _models_PasswordResetRequest
from ..models import UpdatePasswordRequest as _models_UpdatePasswordRequest
from ..models import UserItem as _models_UserItem

_encoder = json.Encoder()
_cookie_decoder = json.Decoder(list[_contracts_Cookie] | None)
_login__body_decoder = json.Decoder(_models_LoginRequest)
_login__200_decoder = json.Decoder(_models_AuthSuccessResponse)
_login__200_header_set_cookie = json.Decoder(list[str] | None)
_login__422_decoder = json.Decoder(_models_HttpValidationError)
_logout__200_decoder = json.Decoder(_models_MessageResponse)
_logout__200_header_set_cookie = json.Decoder(str | None)
_logout__422_decoder = json.Decoder(_models_HttpValidationError)
_get_current_user__200_decoder = json.Decoder(_models_UserItem)
_get_current_user__422_decoder = json.Decoder(_models_HttpValidationError)
_update_password__body_decoder = json.Decoder(_models_UpdatePasswordRequest)
_update_password__200_decoder = json.Decoder(_models_AuthSuccessResponse)
_update_password__200_header_set_cookie = json.Decoder(str | None)
_update_password__422_decoder = json.Decoder(_models_HttpValidationError)
_request_password_reset__body_decoder = json.Decoder(_models_PasswordResetRequest)
_request_password_reset__200_decoder = json.Decoder(_models_MessageResponse)
_request_password_reset__422_decoder = json.Decoder(_models_HttpValidationError)
_reset_password__body_decoder = json.Decoder(_models_PasswordResetConfirmRequest)
_reset_password__200_decoder = json.Decoder(_models_MessageResponse)
_reset_password__422_decoder = json.Decoder(_models_HttpValidationError)
_refresh_token__200_decoder = json.Decoder(_models_AuthSuccessResponse)
_refresh_token__200_header_set_cookie = json.Decoder(str | None)
_refresh_token__422_decoder = json.Decoder(_models_HttpValidationError)


def create_routes(
    handler: AuthHandler, *, 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_login(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(__oapi_bytes, _login__body_decoder, required=True)
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_Login.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handler.login(__oapi_request)
        except (
            _contracts_Login.BadRequest,
            _contracts_Login.Unauthorized,
            _contracts_Login.Forbidden,
            _contracts_Login.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("login error responses must be raised")
        if isinstance(__oapi_result, _contracts_Login.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_cookies = _cookie_decoder.decode(_encoder.encode(__oapi_result.set_cookie))
            __oapi_cookie_headers = (
                [__oapi_cookie.to_header() for __oapi_cookie in __oapi_cookies]
                if __oapi_cookies is not None
                else None
            )
            __oapi_header = _login__200_header_set_cookie.decode(
                _encoder.encode(__oapi_cookie_headers)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_login__200_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_Login.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_Login.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_Login.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_Login.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_login__422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("login returned an unsupported response variant")

    __oapi_route_login = Route(
        prefix + "/auth/login", __oapi_endpoint_login, methods=["POST"], name="login"
    )
    __oapi_routes[("/auth/login", "post")] = __oapi_route_login

    async def __oapi_endpoint_logout(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_Logout.Request()
        try:
            __oapi_result = await __oapi_handler.logout(__oapi_request)
        except _contracts_Logout.UnprocessableEntity as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("logout error responses must be raised")
        if isinstance(__oapi_result, _contracts_Logout.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _logout__200_header_set_cookie.decode(
                _encoder.encode(__oapi_result.set_cookie)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_logout__200_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_Logout.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_logout__422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("logout returned an unsupported response variant")

    __oapi_route_logout = Route(
        prefix + "/auth/logout", __oapi_endpoint_logout, methods=["POST"], name="logout"
    )
    __oapi_routes[("/auth/logout", "post")] = __oapi_route_logout

    async def __oapi_endpoint_get_current_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_credential_bearer_auth = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_credential_bearer_auth is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "getCurrentUser",
                    BearerAuthSecurity(
                        api_key=__oapi_credential_bearer_auth,
                        roles=(),
                    ),
                )
            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")
        __oapi_request = _contracts_GetCurrentUser.Request(security_context=__oapi_security_context)
        try:
            __oapi_result = await __oapi_handler.get_current_user(__oapi_request)
        except (
            _contracts_GetCurrentUser.Unauthorized,
            _contracts_GetCurrentUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("getCurrentUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_GetCurrentUser.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_get_current_user__200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_GetCurrentUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_GetCurrentUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_get_current_user__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("getCurrentUser returned an unsupported response variant")

    __oapi_route_get_current_user = Route(
        prefix + "/auth/me",
        __oapi_endpoint_get_current_user,
        methods=["GET"],
        name="getCurrentUser",
    )
    __oapi_route_get_current_user.methods = {"GET"}
    __oapi_routes[("/auth/me", "get")] = __oapi_route_get_current_user

    async def __oapi_endpoint_update_password(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_credential_bearer_auth = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_credential_bearer_auth is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "updatePassword",
                    BearerAuthSecurity(
                        api_key=__oapi_credential_bearer_auth,
                        roles=(),
                    ),
                )
            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_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _update_password__body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_UpdatePassword.Request(
            body=__oapi_body, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handler.update_password(__oapi_request)
        except (
            _contracts_UpdatePassword.BadRequest,
            _contracts_UpdatePassword.Unauthorized,
            _contracts_UpdatePassword.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("updatePassword error responses must be raised")
        if isinstance(__oapi_result, _contracts_UpdatePassword.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _update_password__200_header_set_cookie.decode(
                _encoder.encode(__oapi_result.set_cookie)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_password__200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_UpdatePassword.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_UpdatePassword.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_UpdatePassword.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_password__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("updatePassword returned an unsupported response variant")

    __oapi_route_update_password = Route(
        prefix + "/auth/password",
        __oapi_endpoint_update_password,
        methods=["PUT"],
        name="updatePassword",
    )
    __oapi_routes[("/auth/password", "put")] = __oapi_route_update_password

    async def __oapi_endpoint_request_password_reset(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _request_password_reset__body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_RequestPasswordReset.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handler.request_password_reset(__oapi_request)
        except _contracts_RequestPasswordReset.UnprocessableEntity as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("requestPasswordReset error responses must be raised")
        if isinstance(__oapi_result, _contracts_RequestPasswordReset.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_request_password_reset__200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_RequestPasswordReset.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_request_password_reset__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("requestPasswordReset returned an unsupported response variant")

    __oapi_route_request_password_reset = Route(
        prefix + "/auth/password/recover",
        __oapi_endpoint_request_password_reset,
        methods=["POST"],
        name="requestPasswordReset",
    )
    __oapi_routes[("/auth/password/recover", "post")] = __oapi_route_request_password_reset

    async def __oapi_endpoint_reset_password(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _reset_password__body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_ResetPassword.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handler.reset_password(__oapi_request)
        except (
            _contracts_ResetPassword.BadRequest,
            _contracts_ResetPassword.Unauthorized,
            _contracts_ResetPassword.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("resetPassword error responses must be raised")
        if isinstance(__oapi_result, _contracts_ResetPassword.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_reset_password__200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_ResetPassword.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_ResetPassword.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_ResetPassword.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_reset_password__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("resetPassword returned an unsupported response variant")

    __oapi_route_reset_password = Route(
        prefix + "/auth/password/reset",
        __oapi_endpoint_reset_password,
        methods=["POST"],
        name="resetPassword",
    )
    __oapi_routes[("/auth/password/reset", "post")] = __oapi_route_reset_password

    async def __oapi_endpoint_refresh_token(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_RefreshToken.Request()
        try:
            __oapi_result = await __oapi_handler.refresh_token(__oapi_request)
        except (
            _contracts_RefreshToken.Unauthorized,
            _contracts_RefreshToken.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("refreshToken error responses must be raised")
        if isinstance(__oapi_result, _contracts_RefreshToken.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _refresh_token__200_header_set_cookie.decode(
                _encoder.encode(__oapi_result.set_cookie)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_refresh_token__200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_RefreshToken.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_RefreshToken.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_refresh_token__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("refreshToken returned an unsupported response variant")

    __oapi_route_refresh_token = Route(
        prefix + "/auth/refresh",
        __oapi_endpoint_refresh_token,
        methods=["POST"],
        name="refreshToken",
    )
    __oapi_routes[("/auth/refresh", "post")] = __oapi_route_refresh_token
    return __oapi_routes
