use crate::service::RoomService;
use models::agents::model as ai_model;
use models::rooms::room_message;
use models::users::user as user_model;
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
use uuid::Uuid;

impl RoomService {
    pub async fn resolve_display_name(
        &self,
        msg: room_message::Model,
        _room_id: Uuid,
    ) -> super::RoomMessageResponse {
        let sender_type = msg.sender_type.to_string();
        let display_name = match sender_type.as_str() {
            "ai" => {
                if let Some(mid) = msg.model_id {
                    ai_model::Entity::find_by_id(mid)
                        .one(&self.db)
                        .await
                        .inspect_err(|e| tracing::warn!(error = %e, model_id = %mid, "resolve_display_name: AI model lookup failed"))
                        .ok()
                        .flatten()
                        .map(|m| m.name)
                        .or_else(|| Some(format!("AI({})", &mid.to_string()[..8])))
                } else {
                    None
                }
            }
            _ => {
                if let Some(sender_id) = msg.sender_id {
                    let user = user_model::Entity::find()
                        .filter(user_model::Column::Uid.eq(sender_id))
                        .one(&self.db)
                        .await
                        .inspect_err(|e| tracing::warn!(error = %e, user_id = %sender_id, "resolve_display_name: user lookup failed"))
                        .ok()
                        .flatten();
                    user.map(|u| u.display_name.unwrap_or_else(|| u.username))
                } else {
                    None
                }
            }
        };

        let chunked = super::RoomMessageResponse::detect_chunked(&msg.thinking_content);
        super::RoomMessageResponse {
            id: msg.id, seq: msg.seq, room: msg.room, sender_type,
            sender_id: msg.sender_id, display_name, thread: msg.thread,
            content: msg.content, content_type: msg.content_type.to_string(),
            thinking_content: msg.thinking_content, thinking_is_chunked: chunked,
            edited_at: msg.edited_at, send_at: msg.send_at, revoked: msg.revoked,
            revoked_by: msg.revoked_by, in_reply_to: msg.in_reply_to,
            highlighted_content: None, attachment_ids: Vec::new(), reactions: Vec::new(),
        }
    }
}