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

from typing import Annotated
from uuid import UUID

from msgspec import Meta, convert, json, to_builtins
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, SecurityHandler, SecurityRejected
from ..contracts.admin import AdminHandler
from ..contracts.admin import CreateUser as _contracts_CreateUser
from ..contracts.admin import DeleteUser as _contracts_DeleteUser
from ..contracts.admin import GetUser as _contracts_GetUser
from ..contracts.admin import ListUsers as _contracts_ListUsers
from ..contracts.admin import UpdateUser as _contracts_UpdateUser
from ..models import CreateUserRequest as _models_CreateUserRequest
from ..models import CreateUserResponse as _models_CreateUserResponse
from ..models import HttpValidationError as _models_HttpValidationError
from ..models import UpdateUserRequest as _models_UpdateUserRequest
from ..models import UserItem as _models_UserItem
from ..models import UserListResponse as _models_UserListResponse

_encoder = json.Encoder()
_list_users__parameter_page = Annotated[int, Meta(ge=1)]
json.Decoder(_list_users__parameter_page)
_list_users__parameter_page_size = Annotated[int, Meta(ge=1, le=100)]
json.Decoder(_list_users__parameter_page_size)
_list_users__200_decoder = json.Decoder(_models_UserListResponse)
_list_users__422_decoder = json.Decoder(_models_HttpValidationError)
_create_user__body_decoder = json.Decoder(_models_CreateUserRequest)
_create_user__201_decoder = json.Decoder(_models_CreateUserResponse)
_create_user__422_decoder = json.Decoder(_models_HttpValidationError)
_delete_user__parameter_user_id = UUID
json.Decoder(_delete_user__parameter_user_id)
_delete_user__422_decoder = json.Decoder(_models_HttpValidationError)
_get_user__parameter_user_id = UUID
json.Decoder(_get_user__parameter_user_id)
_get_user__200_decoder = json.Decoder(_models_UserItem)
_get_user__422_decoder = json.Decoder(_models_HttpValidationError)
_update_user__parameter_user_id = UUID
json.Decoder(_update_user__parameter_user_id)
_update_user__body_properties = {
    "schema": {"$ref": "#/components/schemas/UpdateUserRequest"},
    "references": {
        "#/components/schemas/UpdateUserRequest": {
            "type": "object",
            "minProperties": 1,
            "properties": {
                "last_name": {"type": "string"},
                "first_name": {"type": "string"},
                "patronymic": {"type": "string"},
                "is_active": {"type": "boolean"},
                "must_change_password": {"type": "boolean"},
                "available_licenses": {"type": "array", "items": {"type": "integer"}},
            },
        }
    },
}
_update_user__body_decoder = json.Decoder(_models_UpdateUserRequest)
_update_user__200_decoder = json.Decoder(_models_UserItem)
_update_user__422_decoder = json.Decoder(_models_HttpValidationError)


def create_routes(
    handler: AdminHandler, *, 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_list_users(__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,
                    "listUsers",
                    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_parameter_page = _runtime_parameter(
                __oapi_http.query_params.get("page"),
                _list_users__parameter_page,
                ("query", "page"),
                required=False,
                default=1,
            )
            __oapi_parameter_page_size = _runtime_parameter(
                __oapi_http.query_params.get("page_size"),
                _list_users__parameter_page_size,
                ("query", "page_size"),
                required=False,
                default=20,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_ListUsers.Request(
            page=__oapi_parameter_page,
            page_size=__oapi_parameter_page_size,
            security_context=__oapi_security_context,
        )
        try:
            __oapi_result = await __oapi_handler.list_users(__oapi_request)
        except (
            _contracts_ListUsers.Unauthorized,
            _contracts_ListUsers.Forbidden,
            _contracts_ListUsers.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("listUsers error responses must be raised")
        if isinstance(__oapi_result, _contracts_ListUsers.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_list_users__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_ListUsers.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_ListUsers.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_ListUsers.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_list_users__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("listUsers returned an unsupported response variant")

    __oapi_route_list_users = Route(
        prefix + "/users", __oapi_endpoint_list_users, methods=["GET"], name="listUsers"
    )
    __oapi_route_list_users.methods = {"GET"}
    __oapi_routes[("/users", "get")] = __oapi_route_list_users

    async def __oapi_endpoint_create_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,
                    "createUser",
                    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, _create_user__body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_CreateUser.Request(
            body=__oapi_body, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handler.create_user(__oapi_request)
        except (
            _contracts_CreateUser.BadRequest,
            _contracts_CreateUser.Unauthorized,
            _contracts_CreateUser.Forbidden,
            _contracts_CreateUser.Conflict,
            _contracts_CreateUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("createUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_CreateUser.Created):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_create_user__201_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=201, media_type="application/json")
        if isinstance(__oapi_result, _contracts_CreateUser.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_CreateUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_CreateUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_CreateUser.Conflict):
            return Response(status_code=409)
        if isinstance(__oapi_result, _contracts_CreateUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_create_user__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("createUser returned an unsupported response variant")

    __oapi_route_create_user = Route(
        prefix + "/users", __oapi_endpoint_create_user, methods=["POST"], name="createUser"
    )
    __oapi_routes[("/users", "post")] = __oapi_route_create_user

    async def __oapi_endpoint_delete_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,
                    "deleteUser",
                    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_parameter_user_id = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _delete_user__parameter_user_id,
                ("path", "user_id"),
                required=True,
                default=None,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_DeleteUser.Request(
            user_id=__oapi_parameter_user_id, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handler.delete_user(__oapi_request)
        except (
            _contracts_DeleteUser.Unauthorized,
            _contracts_DeleteUser.Forbidden,
            _contracts_DeleteUser.NotFound,
            _contracts_DeleteUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("deleteUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_DeleteUser.NoContent):
            return Response(status_code=204)
        if isinstance(__oapi_result, _contracts_DeleteUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_DeleteUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_DeleteUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_DeleteUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_delete_user__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("deleteUser returned an unsupported response variant")

    __oapi_route_delete_user = Route(
        prefix + "/users/{user_id}",
        __oapi_endpoint_delete_user,
        methods=["DELETE"],
        name="deleteUser",
    )
    __oapi_routes[("/users/{user_id}", "delete")] = __oapi_route_delete_user

    async def __oapi_endpoint_get_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,
                    "getUser",
                    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_parameter_user_id = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _get_user__parameter_user_id,
                ("path", "user_id"),
                required=True,
                default=None,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_GetUser.Request(
            user_id=__oapi_parameter_user_id, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handler.get_user(__oapi_request)
        except (
            _contracts_GetUser.Unauthorized,
            _contracts_GetUser.Forbidden,
            _contracts_GetUser.NotFound,
            _contracts_GetUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("getUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_GetUser.Ok):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_get_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_GetUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_GetUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_GetUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_GetUser.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_get_user__422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("getUser returned an unsupported response variant")

    __oapi_route_get_user = Route(
        prefix + "/users/{user_id}", __oapi_endpoint_get_user, methods=["GET"], name="getUser"
    )
    __oapi_route_get_user.methods = {"GET"}
    __oapi_routes[("/users/{user_id}", "get")] = __oapi_route_get_user

    async def __oapi_endpoint_update_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,
                    "updateUser",
                    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_parameter_user_id = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _update_user__parameter_user_id,
                ("path", "user_id"),
                required=True,
                default=None,
            )
            __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_user__body_decoder,
                required=True,
                property_counts=_update_user__body_properties,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_UpdateUser.Request(
            user_id=__oapi_parameter_user_id,
            body=__oapi_body,
            security_context=__oapi_security_context,
        )
        try:
            __oapi_result = await __oapi_handler.update_user(__oapi_request)
        except (
            _contracts_UpdateUser.Unauthorized,
            _contracts_UpdateUser.Forbidden,
            _contracts_UpdateUser.NotFound,
            _contracts_UpdateUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("updateUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_UpdateUser.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_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_UpdateUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_UpdateUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_UpdateUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_UpdateUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_user__422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("updateUser returned an unsupported response variant")

    __oapi_route_update_user = Route(
        prefix + "/users/{user_id}",
        __oapi_endpoint_update_user,
        methods=["PATCH"],
        name="updateUser",
    )
    __oapi_routes[("/users/{user_id}", "patch")] = __oapi_route_update_user
    return __oapi_routes
