use models::room::room_members;
use models::room::rooms::{self};
use sea_orm::EntityTrait;
use space::{Member, Space};

use uuid::Uuid;

use crate::errors::ChatError;
use crate::services::service::ChatService;

pub struct RoomContext {
    pub room: rooms::Model,
    pub space: Option<Space>,
    pub is_dm: bool,
}

impl RoomContext {}

/// Route slug (`lower_name`) of the space owning `space_id`, or `None` for a
/// DM. Notification payloads carry it so the inbox can deep-link straight to
/// `/app/{slug}/chat/{room}` without a second round trip.
pub async fn space_slug_for(service: &ChatService, space_id: Option<Uuid>) -> Option<String> {
    let space_id = space_id?;
    service
        .participants
        .access
        .by_id(space_id)
        .await
        .ok()
        .map(|space| space.slug().to_owned())
}

pub async fn lookup_room(service: &ChatService, room_id: Uuid) -> Result<rooms::Model, ChatError> {
    rooms::Entity::find_by_id(room_id)
        .one(service.database.read())
        .await?
        .filter(|r| r.is_active)
        .ok_or(ChatError::NotFound)
}

pub async fn load_room_context(
    service: &ChatService,
    room: rooms::Model,
) -> Result<RoomContext, ChatError> {
    let is_dm = room.space_id.is_none();
    let space = match room.space_id {
        Some(space_id) => Some(service.participants.access.by_id(space_id).await?),
        None => None,
    };
    Ok(RoomContext { room, space, is_dm })
}

pub async fn lookup_room_context(
    service: &ChatService,
    room_id: Uuid,
) -> Result<RoomContext, ChatError> {
    let room = lookup_room(service, room_id).await?;
    load_room_context(service, room).await
}

/// 空间频道对空间成员开放；私密频道与 DM 需要 `room_members` 行，owner 总是可读。
async fn room_visible(
    service: &ChatService,
    room: &rooms::Model,
    space: Option<&Space>,
    uid: i64,
) -> Result<bool, ChatError> {
    if room.space_id.is_some() && space.is_none() {
        return Ok(false);
    }
    if space.is_some() && (!room.is_private || room.owner_id == uid) {
        return Ok(true);
    }
    is_room_member_row(service, room.id, uid).await
}

async fn is_room_member_row(
    service: &ChatService,
    room_id: Uuid,
    uid: i64,
) -> Result<bool, ChatError> {
    Ok(room_members::Entity::find_by_id((room_id, uid))
        .one(service.database.read())
        .await?
        .is_some_and(|m| m.left_at.is_none()))
}

pub async fn is_room_member(
    service: &ChatService,
    room_id: Uuid,
    uid: i64,
) -> Result<bool, ChatError> {
    let ctx = lookup_room_context(service, room_id).await?;
    room_visible(service, &ctx.room, ctx.space.as_ref(), uid).await
}

pub async fn lookup_space_by_name(
    service: &ChatService,
    space_name: &str,
) -> Result<Space, ChatError> {
    Ok(service.participants.access.by_slug(space_name).await?)
}

pub async fn require_space_member(
    _service: &ChatService,
    space: &Space,
    uid: i64,
) -> Result<Member, ChatError> {
    Ok(space.require_member(uid).await?)
}

pub async fn require_room_writable(
    service: &ChatService,
    room_id: Uuid,
    uid: i64,
) -> Result<RoomContext, ChatError> {
    let ctx = require_room_readable(service, room_id, uid).await?;
    if let Some(space) = &ctx.space {
        space::require(space, uid, space::Capability::Message).await?;
    }
    Ok(ctx)
}

pub async fn require_room_readable(
    service: &ChatService,
    room_id: Uuid,
    uid: i64,
) -> Result<RoomContext, ChatError> {
    let ctx = lookup_room_context(service, room_id).await?;
    match &ctx.space {
        Some(space) => {
            require_space_member(service, space, uid).await?;
            if !room_visible(service, &ctx.room, Some(space), uid).await? {
                return Err(ChatError::Forbidden);
            }
        }
        None => {
            if !room_visible(service, &ctx.room, None, uid).await? {
                return Err(ChatError::Forbidden);
            }
        }
    }
    Ok(ctx)
}