/**
 * 空间「对象清理」：仅空间所有者可见的危险区。
 *
 * 仓库、问题看板、频道各自持有空间归属，这里把它们拍成一张扁平清单，
 * 并提供「删除 / 归档 / 可见性」操作。对象一律按自己的主键寻址。
 */
use ::session::AuthedUser;
use api::http::routing::{delete, get, post};
use api::http::{Json, Path, Router, State};
use api::rest::{AppResponseData, NoData};
use models::issue::issues as boards;
use models::repo::repos;
use models::room::rooms;
use sea_orm::ActiveValue::Set;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter};
use serde::{Deserialize, Serialize};
use utoipa::{OpenApi, ToSchema};
use uuid::Uuid;

use git::service::GitService;
use issues::services::service::IssueService;
use space::errors::SpaceError;
use space::services::service::SpaceService;
use space::share::lookup;

api::api_error! {
    log: "cleanup",
    pub enum ApiError {
        BadRequest(400, "request failed validation"),
        Unauthorized(401, "authentication required"),
        Forbidden(403, "operation not allowed"),
        NotFound(404, "resource not found"),
        Internal(500, "internal server error"),
    }
}

#[derive(Clone)]
pub struct CleanupState {
    pub database: std::sync::Arc<db::AppDatabase>,
    pub space: SpaceService,
    pub chat: chat::services::service::ChatService,
    pub issues: IssueService,
    pub git: GitService,
}

#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct CleanupObjectDto {
    /// `repos.id`、`issues.id`（看板）或 `rooms.id`。
    pub id: Uuid,
    /// `repo | board | text | voice | stage | category | news | guild_room`
    pub kind: String,
    pub name: String,
    /// 仅仓库与频道有可见性开关。
    pub is_private: Option<bool>,
    pub is_archived: bool,
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct SetCleanupVisibilityCmd {
    pub is_private: bool,
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct SetRepoArchivedCmd {
    pub archived: bool,
}

fn room_kind_label(kind: models::room::rooms::RoomKind) -> &'static str {
    use models::room::rooms::RoomKind;
    match kind {
        RoomKind::Text => "text",
        RoomKind::Voice => "voice",
        RoomKind::Stage => "stage",
        RoomKind::Category => "category",
        RoomKind::News => "news",
        RoomKind::GuildRoom => "guild_room",
        _ => "thread",
    }
}

pub fn protected(
    database: std::sync::Arc<db::AppDatabase>,
    space: SpaceService,
    chat: chat::services::service::ChatService,
    issues: IssueService,
    git: GitService,
) -> Router {
    let state = CleanupState {
        database,
        space,
        chat,
        issues,
        git,
    };
    Router::<()>::new()
        .route("/spaces/{space_name}/cleanup", get(list_cleanup_objects))
        .route(
            "/spaces/{space_name}/cleanup/{kind}/{object_id}/visibility",
            post(set_cleanup_visibility),
        )
        .route(
            "/spaces/{space_name}/cleanup/{kind}/{object_id}/archive",
            post(set_cleanup_archive),
        )
        .route(
            "/spaces/{space_name}/cleanup/{kind}/{object_id}",
            delete(delete_cleanup_object),
        )
        .with_state(state)
}

fn map_space(error: SpaceError) -> ApiError {
    match error {
        SpaceError::BadRequest(message) => ApiError::bad_request(message),
        SpaceError::Unauthorized => ApiError::unauthorized(),
        SpaceError::Forbidden => ApiError::forbidden(),
        SpaceError::NotFound => ApiError::not_found("resource not found"),
        other => ApiError::internal(other.to_string()),
    }
}

fn map_git(error: git::share::errors::GitError) -> ApiError {
    use git::share::errors::GitError;
    match error {
        GitError::InvalidArgument(message) | GitError::Conflict(message) => {
            ApiError::bad_request(message)
        }
        GitError::Unauthorized => ApiError::unauthorized(),
        GitError::Forbidden => ApiError::forbidden(),
        GitError::NotFound => ApiError::not_found("resource not found"),
        other => ApiError::internal(other.to_string()),
    }
}

fn map_issue(error: issues::errors::IssueError) -> ApiError {
    use issues::errors::IssueError;
    match error {
        IssueError::BadRequest(message) | IssueError::Conflict(message) => {
            ApiError::bad_request(message)
        }
        IssueError::Unauthorized => ApiError::unauthorized(),
        IssueError::Forbidden => ApiError::forbidden(),
        IssueError::NotFound => ApiError::not_found("resource not found"),
        other => ApiError::internal(other.to_string()),
    }
}

fn map_chat(error: chat::errors::ChatError) -> ApiError {
    use chat::errors::ChatError;
    match error {
        ChatError::BadRequest(message) | ChatError::Conflict(message) => {
            ApiError::bad_request(message)
        }
        ChatError::Unauthorized => ApiError::unauthorized(),
        ChatError::Forbidden => ApiError::forbidden(),
        ChatError::NotFound => ApiError::not_found("resource not found"),
        ChatError::RateLimited(message) => ApiError::bad_request(message),
        other => ApiError::internal(other.to_string()),
    }
}

fn db_internal(error: sea_orm::DbErr) -> ApiError {
    ApiError::internal(error.to_string())
}

async fn require_owner(
    state: &CleanupState,
    space_name: &str,
    uid: i64,
) -> Result<models::space::spaces::Model, ApiError> {
    let space = lookup::lookup_space_by_name(&state.space, space_name)
        .await
        .map_err(map_space)?;
    if space.owner_user_id != uid {
        return Err(ApiError::forbidden());
    }
    Ok(space)
}

async fn repo_in_space(
    db: &impl sea_orm::ConnectionTrait,
    space_id: Uuid,
    repo_id: Uuid,
) -> Result<repos::Model, ApiError> {
    repos::Entity::find_by_id(repo_id)
        .filter(repos::Column::SpaceId.eq(space_id))
        .one(db)
        .await
        .map_err(db_internal)?
        .ok_or_else(|| ApiError::not_found("repository not found"))
}

async fn room_in_space(
    db: &impl sea_orm::ConnectionTrait,
    space_id: Uuid,
    room_id: Uuid,
) -> Result<rooms::Model, ApiError> {
    rooms::Entity::find_by_id(room_id)
        .filter(rooms::Column::SpaceId.eq(space_id))
        .one(db)
        .await
        .map_err(db_internal)?
        .ok_or_else(|| ApiError::not_found("room not found"))
}

#[utoipa::path(
    get,
    path = "/spaces/{space_name}/cleanup",
    tag = "cleanup",
    description = "列出空间内全部仓库、问题看板与频道，仅空间所有者可访问。",
    params(("space_name" = String, Path, description = "space name")),
    responses(
        (status = 200, description = "cleanup objects", body = AppResponseData<Vec<CleanupObjectDto>>)
    )
)]
pub async fn list_cleanup_objects(
    State(state): State<CleanupState>,
    AuthedUser(uid): AuthedUser,
    Path(space_name): Path<String>,
) -> Result<AppResponseData<Vec<CleanupObjectDto>>, ApiError> {
    let space = require_owner(&state, &space_name, uid).await?;
    let db = &state.database;

    let repo_rows = repos::Entity::find()
        .filter(repos::Column::SpaceId.eq(space.id))
        .all(db.read())
        .await
        .map_err(db_internal)?;
    let board_rows = boards::Entity::find()
        .filter(boards::Column::SpaceId.eq(space.id))
        .all(db.read())
        .await
        .map_err(db_internal)?;
    let room_rows = rooms::Entity::find()
        .filter(rooms::Column::SpaceId.eq(space.id))
        .all(db.read())
        .await
        .map_err(db_internal)?;

    let mut items = Vec::with_capacity(repo_rows.len() + board_rows.len() + room_rows.len());
    for repo in repo_rows {
        items.push(CleanupObjectDto {
            id: repo.id,
            kind: "repo".to_owned(),
            name: repo.name,
            is_private: Some(repo.is_private),
            is_archived: repo.is_archived,
        });
    }
    for board in board_rows {
        items.push(CleanupObjectDto {
            id: board.id,
            kind: "board".to_owned(),
            name: board.name,
            is_private: None,
            is_archived: false,
        });
    }
    for room in room_rows {
        items.push(CleanupObjectDto {
            id: room.id,
            kind: room_kind_label(room.kind).to_owned(),
            name: room.name,
            is_private: Some(room.is_private),
            is_archived: !room.is_active,
        });
    }
    items.sort_by(|a, b| a.kind.cmp(&b.kind).then_with(|| a.name.cmp(&b.name)));

    Ok(AppResponseData::ok(items))
}

#[utoipa::path(
    post,
    path = "/spaces/{space_name}/cleanup/{kind}/{object_id}/visibility",
    tag = "cleanup",
    description = "切换仓库或频道的可见性（私密 / 空间内公开）。",
    params(
        ("space_name" = String, Path, description = "space name"),
        ("kind" = String, Path, description = "object kind"),
        ("object_id" = Uuid, Path, description = "repo id or room id")
    ),
    request_body = SetCleanupVisibilityCmd,
    responses((status = 200, description = "updated", body = AppResponseData<NoData>))
)]
pub async fn set_cleanup_visibility(
    State(state): State<CleanupState>,
    AuthedUser(uid): AuthedUser,
    Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,
    Json(cmd): Json<SetCleanupVisibilityCmd>,
) -> Result<AppResponseData<NoData>, ApiError> {
    let space = require_owner(&state, &space_name, uid).await?;
    let db = &state.database;

    match kind.as_str() {
        "repo" => {
            let repo = repo_in_space(db.read(), space.id, object_id).await?;
            let update = git::service::repos::UpdateRepoCmd {
                is_private: Some(cmd.is_private),
                ..Default::default()
            };
            let ctx = state
                .git
                .context(space_name.clone(), repo.name.clone())
                .await
                .map_err(map_git)?;
            state
                .git
                .update_repo(&ctx, uid, update)
                .await
                .map_err(map_git)?;
        }
        "text" | "voice" | "stage" | "category" | "news" | "guild_room" | "thread" => {
            let room = room_in_space(db.read(), space.id, object_id).await?;
            let mut am: rooms::ActiveModel = room.into();
            am.is_private = Set(cmd.is_private);
            am.updated_at = Set(time::OffsetDateTime::now_utc());
            am.update(db.write()).await.map_err(db_internal)?;
        }
        _ => {
            return Err(ApiError::bad_request(
                "visibility is not adjustable for this object type",
            ));
        }
    }
    Ok(AppResponseData::empty())
}

#[utoipa::path(
    post,
    path = "/spaces/{space_name}/cleanup/{kind}/{object_id}/archive",
    tag = "cleanup",
    description = "归档 / 取消归档仓库；仓库没有硬删除，危险区用归档表达下架。",
    params(
        ("space_name" = String, Path, description = "space name"),
        ("kind" = String, Path, description = "object kind"),
        ("object_id" = Uuid, Path, description = "repo id")
    ),
    request_body = SetRepoArchivedCmd,
    responses((status = 200, description = "updated", body = AppResponseData<NoData>))
)]
pub async fn set_cleanup_archive(
    State(state): State<CleanupState>,
    AuthedUser(uid): AuthedUser,
    Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,
    Json(cmd): Json<SetRepoArchivedCmd>,
) -> Result<AppResponseData<NoData>, ApiError> {
    let space = require_owner(&state, &space_name, uid).await?;
    if kind != "repo" {
        return Err(ApiError::bad_request("only repositories support archiving"));
    }
    let repo = repo_in_space(state.database.read(), space.id, object_id).await?;
    let ctx = state
        .git
        .context(space_name.clone(), repo.name.clone())
        .await
        .map_err(map_git)?;
    state
        .git
        .set_repo_archived(&ctx, uid, cmd.archived)
        .await
        .map_err(map_git)?;
    Ok(AppResponseData::empty())
}

#[utoipa::path(
    delete,
    path = "/spaces/{space_name}/cleanup/{kind}/{object_id}",
    tag = "cleanup",
    description = "删除对象：问题看板与频道调用各自模块的清理逻辑；仓库只能用归档。",
    params(
        ("space_name" = String, Path, description = "space name"),
        ("kind" = String, Path, description = "object kind"),
        ("object_id" = Uuid, Path, description = "board id or room id")
    ),
    responses((status = 200, description = "deleted", body = AppResponseData<NoData>))
)]
pub async fn delete_cleanup_object(
    State(state): State<CleanupState>,
    AuthedUser(uid): AuthedUser,
    Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,
) -> Result<AppResponseData<NoData>, ApiError> {
    let space = require_owner(&state, &space_name, uid).await?;
    let db = &state.database;

    match kind.as_str() {
        "repo" => {
            return Err(ApiError::bad_request(
                "repositories cannot be deleted here; archive them instead",
            ));
        }
        "board" => {
            let board = boards::Entity::find_by_id(object_id)
                .filter(boards::Column::SpaceId.eq(space.id))
                .one(db.read())
                .await
                .map_err(db_internal)?
                .ok_or_else(|| ApiError::not_found("board not found"))?;
            state
                .issues
                .delete_board(uid, &space_name, board.id)
                .await
                .map_err(map_issue)?;
        }
        "text" | "voice" | "stage" | "category" | "news" | "guild_room" | "thread" => {
            let room = room_in_space(db.read(), space.id, object_id).await?;
            state
                .chat
                .delete_room(uid, room.id)
                .await
                .map_err(map_chat)?;
        }
        _ => {
            return Err(ApiError::bad_request("unsupported object kind"));
        }
    }
    Ok(AppResponseData::empty())
}

#[derive(OpenApi)]
#[openapi(
    paths(
        crate::cleanup::list_cleanup_objects,
        crate::cleanup::set_cleanup_visibility,
        crate::cleanup::set_cleanup_archive,
        crate::cleanup::delete_cleanup_object,
    ),
    components(schemas(
        crate::cleanup::CleanupObjectDto,
        crate::cleanup::SetCleanupVisibilityCmd,
        crate::cleanup::SetRepoArchivedCmd,
        AppResponseData<Vec<crate::cleanup::CleanupObjectDto>>,
        AppResponseData<NoData>,
    ))
)]
pub struct CleanupApiDoc;