use tonic::{Request, Response, Status};

use crate::proto as pb;
use crate::proto::admin_server::Admin;
use crate::service::AdminRpc;

#[tonic::async_trait]
impl Admin for AdminRpc {
    async fn system_status(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::SystemStatus>, Status> {
        crate::service::system::system_status(self, request).await
    }

    async fn system_config(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::SystemConfig>, Status> {
        crate::service::system::system_config(self, request).await
    }

    async fn dashboard(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::Dashboard>, Status> {
        crate::service::system::dashboard(self, request).await
    }

    async fn list_repos(
        &self,
        request: Request<pb::ListReposRequest>,
    ) -> Result<Response<pb::RepoPage>, Status> {
        crate::service::repos::list_repos(self, request).await
    }

    async fn get_repo(
        &self,
        request: Request<pb::GetRepoRequest>,
    ) -> Result<Response<pb::Repo>, Status> {
        crate::service::repos::get_repo(self, request).await
    }

    async fn update_repo(
        &self,
        request: Request<pb::UpdateRepoRequest>,
    ) -> Result<Response<pb::Repo>, Status> {
        crate::service::repos::update_repo(self, request).await
    }

    async fn list_mcp_tools(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::McpToolList>, Status> {
        crate::service::mcp::list_mcp_tools(self, request).await
    }

    async fn update_mcp_tool(
        &self,
        request: Request<pb::UpdateMcpToolRequest>,
    ) -> Result<Response<pb::McpTool>, Status> {
        crate::service::mcp::update_mcp_tool(self, request).await
    }

    async fn get_act_summary(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::ActSummary>, Status> {
        crate::service::act::get_act_summary(self, request).await
    }

    async fn list_act_runs(
        &self,
        request: Request<pb::ListActRunsRequest>,
    ) -> Result<Response<pb::ActRunPage>, Status> {
        crate::service::act::list_act_runs(self, request).await
    }

    async fn cancel_act_run(
        &self,
        request: Request<pb::CancelActRunRequest>,
    ) -> Result<Response<pb::ActRunRef>, Status> {
        crate::service::act::cancel_act_run(self, request).await
    }

    async fn rerun_act_run(
        &self,
        request: Request<pb::RerunActRunRequest>,
    ) -> Result<Response<pb::ActRunRef>, Status> {
        crate::service::act::rerun_act_run(self, request).await
    }

    async fn get_storage_overview(
        &self,
        request: Request<pb::GetStorageOverviewRequest>,
    ) -> Result<Response<pb::StorageOverview>, Status> {
        crate::service::storage::get_storage_overview(self, request).await
    }

    async fn list_storage_objects(
        &self,
        request: Request<pb::ListStorageObjectsRequest>,
    ) -> Result<Response<pb::StorageObjectPage>, Status> {
        crate::service::storage::list_storage_objects(self, request).await
    }

    async fn get_storage_download_url(
        &self,
        request: Request<pb::GetStorageDownloadUrlRequest>,
    ) -> Result<Response<pb::DownloadUrl>, Status> {
        crate::service::storage::get_storage_download_url(self, request).await
    }

    async fn delete_storage_object(
        &self,
        request: Request<pb::DeleteStorageObjectRequest>,
    ) -> Result<Response<pb::DeleteObjectResp>, Status> {
        crate::service::storage::delete_storage_object(self, request).await
    }

    async fn list_queues(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::QueueList>, Status> {
        crate::service::queues::list_queues(self, request).await
    }

    async fn list_queue_failed_jobs(
        &self,
        request: Request<pb::ListQueueFailedJobsRequest>,
    ) -> Result<Response<pb::JobLogPage>, Status> {
        crate::service::queues::list_queue_failed_jobs(self, request).await
    }

    async fn requeue_queue_failed(
        &self,
        request: Request<pb::RequeueQueueFailedRequest>,
    ) -> Result<Response<pb::QueueActionResp>, Status> {
        crate::service::queues::requeue_queue_failed(self, request).await
    }

    async fn purge_queue(
        &self,
        request: Request<pb::PurgeQueueRequest>,
    ) -> Result<Response<pb::QueueActionResp>, Status> {
        crate::service::queues::purge_queue(self, request).await
    }

    async fn list_job_logs(
        &self,
        request: Request<pb::ListJobLogsRequest>,
    ) -> Result<Response<pb::JobLogPage>, Status> {
        crate::service::logs::list_job_logs(self, request).await
    }

    async fn list_users(
        &self,
        request: Request<pb::ListUsersRequest>,
    ) -> Result<Response<pb::AdminUserPage>, Status> {
        crate::service::users::list_users(self, request).await
    }

    async fn create_user(
        &self,
        request: Request<pb::CreateUserRequest>,
    ) -> Result<Response<pb::CreateUserResp>, Status> {
        crate::service::users::create_user(self, request).await
    }

    async fn get_user(
        &self,
        request: Request<pb::GetUserRequest>,
    ) -> Result<Response<pb::AdminUserDetail>, Status> {
        crate::service::users::get_user(self, request).await
    }

    async fn update_user(
        &self,
        request: Request<pb::UpdateUserRequest>,
    ) -> Result<Response<pb::AdminUser>, Status> {
        crate::service::users::update_user(self, request).await
    }

    async fn delete_user(
        &self,
        request: Request<pb::DeleteUserRequest>,
    ) -> Result<Response<pb::DeleteUserResp>, Status> {
        crate::service::users::delete_user(self, request).await
    }

    async fn suspend_user(
        &self,
        request: Request<pb::SuspendUserRequest>,
    ) -> Result<Response<pb::AdminSuspension>, Status> {
        crate::service::users::suspend_user(self, request).await
    }

    async fn revoke_suspension(
        &self,
        request: Request<pb::RevokeSuspensionRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::users::revoke_suspension(self, request).await
    }

    async fn reset_user_password(
        &self,
        request: Request<pb::ResetUserPasswordRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::users::reset_user_password(self, request).await
    }

    async fn revoke_user_sessions(
        &self,
        request: Request<pb::RevokeUserSessionsRequest>,
    ) -> Result<Response<pb::RevokeSessionsResp>, Status> {
        crate::service::users::revoke_user_sessions(self, request).await
    }

    async fn list_user_sessions(
        &self,
        request: Request<pb::ListUserSessionsRequest>,
    ) -> Result<Response<pb::AdminUserSessionPage>, Status> {
        crate::service::users::list_user_sessions(self, request).await
    }

    async fn revoke_user_session(
        &self,
        request: Request<pb::RevokeUserSessionRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::users::revoke_user_session(self, request).await
    }

    async fn get_user_security(
        &self,
        request: Request<pb::GetUserSecurityRequest>,
    ) -> Result<Response<pb::AdminUserSecurity>, Status> {
        crate::service::users::get_user_security(self, request).await
    }

    async fn clear_user_two_factor(
        &self,
        request: Request<pb::ClearUserTwoFactorRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::users::clear_user_two_factor(self, request).await
    }

    async fn bulk_users(
        &self,
        request: Request<pb::BulkUsersRequest>,
    ) -> Result<Response<pb::BulkUsersResp>, Status> {
        crate::service::users::bulk_users(self, request).await
    }

    async fn export_users(
        &self,
        request: Request<pb::ExportUsersRequest>,
    ) -> Result<Response<pb::ExportUsersResp>, Status> {
        crate::service::users::export_users(self, request).await
    }

    async fn list_spaces(
        &self,
        request: Request<pb::ListSpacesRequest>,
    ) -> Result<Response<pb::AdminSpacePage>, Status> {
        crate::service::spaces::list_spaces(self, request).await
    }

    async fn get_space(
        &self,
        request: Request<pb::GetSpaceRequest>,
    ) -> Result<Response<pb::AdminSpaceDetail>, Status> {
        crate::service::spaces::get_space(self, request).await
    }

    async fn update_space(
        &self,
        request: Request<pb::UpdateSpaceRequest>,
    ) -> Result<Response<pb::AdminSpaceDetail>, Status> {
        crate::service::spaces::update_space(self, request).await
    }

    async fn transfer_space(
        &self,
        request: Request<pb::TransferSpaceRequest>,
    ) -> Result<Response<pb::AdminSpaceDetail>, Status> {
        crate::service::spaces::transfer_space(self, request).await
    }

    async fn delete_space(
        &self,
        request: Request<pb::DeleteSpaceRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::spaces::delete_space(self, request).await
    }

    async fn list_space_members(
        &self,
        request: Request<pb::ListSpaceMembersRequest>,
    ) -> Result<Response<pb::AdminSpaceMemberPage>, Status> {
        crate::service::spaces::list_space_members(self, request).await
    }

    async fn add_space_member(
        &self,
        request: Request<pb::AddSpaceMemberRequest>,
    ) -> Result<Response<pb::AddSpaceMemberResp>, Status> {
        crate::service::spaces::add_space_member(self, request).await
    }

    async fn remove_space_member(
        &self,
        request: Request<pb::RemoveSpaceMemberRequest>,
    ) -> Result<Response<pb::RemoveSpaceMemberResp>, Status> {
        crate::service::spaces::remove_space_member(self, request).await
    }

    async fn list_tasks(
        &self,
        request: Request<pb::ListTasksRequest>,
    ) -> Result<Response<pb::TaskPage>, Status> {
        crate::service::tasks::list_tasks(self, request).await
    }

    async fn get_task(
        &self,
        request: Request<pb::GetTaskRequest>,
    ) -> Result<Response<pb::TaskDetail>, Status> {
        crate::service::tasks::get_task(self, request).await
    }

    async fn retry_task(
        &self,
        request: Request<pb::RetryTaskRequest>,
    ) -> Result<Response<pb::TaskActionResp>, Status> {
        crate::service::tasks::retry_task(self, request).await
    }

    async fn cancel_task(
        &self,
        request: Request<pb::CancelTaskRequest>,
    ) -> Result<Response<pb::TaskActionResp>, Status> {
        crate::service::tasks::cancel_task(self, request).await
    }

    async fn delete_task(
        &self,
        request: Request<pb::DeleteTaskRequest>,
    ) -> Result<Response<pb::Empty>, Status> {
        crate::service::tasks::delete_task(self, request).await
    }

    async fn get_task_stats(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::TaskStats>, Status> {
        crate::service::tasks::get_task_stats(self, request).await
    }

    async fn bulk_tasks(
        &self,
        request: Request<pb::BulkTasksRequest>,
    ) -> Result<Response<pb::BulkTasksResp>, Status> {
        crate::service::tasks::bulk_tasks(self, request).await
    }

    async fn list_runners(
        &self,
        request: Request<pb::ListRunnersRequest>,
    ) -> Result<Response<pb::RunnerPage>, Status> {
        crate::service::runners::list_runners(self, request).await
    }

    async fn update_runner(
        &self,
        request: Request<pb::UpdateRunnerRequest>,
    ) -> Result<Response<pb::Runner>, Status> {
        crate::service::runners::update_runner(self, request).await
    }

    async fn delete_runner(
        &self,
        request: Request<pb::DeleteRunnerRequest>,
    ) -> Result<Response<pb::RunnerList>, Status> {
        crate::service::runners::delete_runner(self, request).await
    }

    async fn list_runner_tokens(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::RunnerTokenList>, Status> {
        crate::service::runners::list_runner_tokens(self, request).await
    }

    async fn create_runner_token(
        &self,
        request: Request<pb::CreateRunnerTokenRequest>,
    ) -> Result<Response<pb::CreatedRunnerToken>, Status> {
        crate::service::runners::create_runner_token(self, request).await
    }

    async fn revoke_runner_token(
        &self,
        request: Request<pb::RevokeRunnerTokenRequest>,
    ) -> Result<Response<pb::RunnerTokenList>, Status> {
        crate::service::runners::revoke_runner_token(self, request).await
    }

    async fn list_environments(
        &self,
        request: Request<pb::ListEnvironmentsRequest>,
    ) -> Result<Response<pb::EnvironmentAdminList>, Status> {
        crate::service::runners::list_environments(self, request).await
    }

    async fn upsert_environment(
        &self,
        request: Request<pb::UpsertEnvironmentRequest>,
    ) -> Result<Response<pb::EnvironmentAdmin>, Status> {
        crate::service::runners::upsert_environment(self, request).await
    }

    async fn delete_environment(
        &self,
        request: Request<pb::DeleteEnvironmentRequest>,
    ) -> Result<Response<pb::EnvironmentAdminList>, Status> {
        crate::service::runners::delete_environment(self, request).await
    }

    async fn upsert_environment_secret(
        &self,
        request: Request<pb::UpsertEnvironmentSecretRequest>,
    ) -> Result<Response<pb::EnvironmentAdminList>, Status> {
        crate::service::runners::upsert_environment_secret(self, request).await
    }

    async fn delete_environment_secret(
        &self,
        request: Request<pb::DeleteEnvironmentSecretRequest>,
    ) -> Result<Response<pb::EnvironmentAdminList>, Status> {
        crate::service::runners::delete_environment_secret(self, request).await
    }

    async fn get_chat_stats(
        &self,
        request: Request<pb::Empty>,
    ) -> Result<Response<pb::AdminChatStats>, Status> {
        crate::service::chat::get_chat_stats(self, request).await
    }

    async fn list_chat_rooms(
        &self,
        request: Request<pb::ListChatRoomsRequest>,
    ) -> Result<Response<pb::AdminChatRoomPage>, Status> {
        crate::service::chat::list_chat_rooms(self, request).await
    }

    async fn get_chat_room(
        &self,
        request: Request<pb::GetChatRoomRequest>,
    ) -> Result<Response<pb::AdminChatRoomDetail>, Status> {
        crate::service::chat::get_chat_room(self, request).await
    }

    async fn update_chat_room(
        &self,
        request: Request<pb::UpdateChatRoomRequest>,
    ) -> Result<Response<pb::AdminChatRoomDetail>, Status> {
        crate::service::chat::update_chat_room(self, request).await
    }

    async fn delete_chat_room(
        &self,
        request: Request<pb::DeleteChatRoomRequest>,
    ) -> Result<Response<pb::DeleteChatRoomResp>, Status> {
        crate::service::chat::delete_chat_room(self, request).await
    }

    async fn list_chat_room_members(
        &self,
        request: Request<pb::ListChatRoomMembersRequest>,
    ) -> Result<Response<pb::AdminChatRoomMemberPage>, Status> {
        crate::service::chat::list_chat_room_members(self, request).await
    }

    async fn remove_chat_room_member(
        &self,
        request: Request<pb::RemoveChatRoomMemberRequest>,
    ) -> Result<Response<pb::RemoveChatMemberResp>, Status> {
        crate::service::chat::remove_chat_room_member(self, request).await
    }

    async fn purge_chat_room(
        &self,
        request: Request<pb::PurgeChatRoomRequest>,
    ) -> Result<Response<pb::PurgeChatMessagesResp>, Status> {
        crate::service::chat::purge_chat_room(self, request).await
    }

    async fn list_chat_messages(
        &self,
        request: Request<pb::ListChatMessagesRequest>,
    ) -> Result<Response<pb::AdminChatMessagePage>, Status> {
        crate::service::chat::list_chat_messages(self, request).await
    }

    async fn export_chat_messages(
        &self,
        request: Request<pb::ExportChatMessagesRequest>,
    ) -> Result<Response<pb::ExportChatMessagesResp>, Status> {
        crate::service::chat::export_chat_messages(self, request).await
    }

    async fn get_chat_message(
        &self,
        request: Request<pb::GetChatMessageRequest>,
    ) -> Result<Response<pb::AdminChatMessageDetail>, Status> {
        crate::service::chat::get_chat_message(self, request).await
    }

    async fn bulk_delete_chat_messages(
        &self,
        request: Request<pb::BulkDeleteChatMessagesRequest>,
    ) -> Result<Response<pb::BulkDeleteChatMessagesResp>, Status> {
        crate::service::chat::bulk_delete_chat_messages(self, request).await
    }

    async fn list_chat_attachments(
        &self,
        request: Request<pb::ListChatAttachmentsRequest>,
    ) -> Result<Response<pb::AdminChatAttachmentPage>, Status> {
        crate::service::chat::list_chat_attachments(self, request).await
    }

    async fn delete_chat_attachment(
        &self,
        request: Request<pb::DeleteChatAttachmentRequest>,
    ) -> Result<Response<pb::DeleteChatAttachmentResp>, Status> {
        crate::service::chat::delete_chat_attachment(self, request).await
    }
}