use models::chat::user_drafts;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::ToSchema;
use uuid::Uuid;

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

#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct DraftDto {
    pub room_id: Uuid,
    pub thread_id: Option<Uuid>,
    pub content: String,
    pub updated_at: OffsetDateTime,
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpsertDraftCmd {
    #[serde(default)]
    pub thread_id: Option<Uuid>,
    pub content: String,
}

impl ChatService {
    pub async fn upsert_draft(
        &self,
        caller: i64,
        room_id: Uuid,
        cmd: UpsertDraftCmd,
    ) -> Result<DraftDto, ChatError> {
        let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
        if cmd.content.chars().count() > self.settings.chat.max_message_len {
            return Err(ChatError::BadRequest("draft too long".to_string()));
        }
        let now = OffsetDateTime::now_utc();

        let mut existing: Option<user_drafts::Model> = None;
        let candidates = user_drafts::Entity::find()
            .filter(user_drafts::Column::UserId.eq(caller))
            .filter(user_drafts::Column::RoomId.eq(room_id))
            .all(self.database.write())
            .await?;
        for row in candidates {
            if row.thread_id == cmd.thread_id {
                existing = Some(row);
                break;
            }
        }

        match existing {
            Some(row) => {
                if cmd.content.is_empty() {
                    user_drafts::Entity::delete_by_id(row.id)
                        .exec(self.database.write())
                        .await?;
                    return Ok(DraftDto {
                        room_id,
                        thread_id: cmd.thread_id,
                        content: String::new(),
                        updated_at: now,
                    });
                }
                let mut am: user_drafts::ActiveModel = row.into();
                am.content = Set(cmd.content.clone());
                am.updated_at = Set(now);
                am.update(self.database.write()).await?;
            }
            None => {
                if !cmd.content.is_empty() {
                    user_drafts::ActiveModel {
                        id: Set(Uuid::now_v7()),
                        user_id: Set(caller),
                        room_id: Set(room_id),
                        thread_id: Set(cmd.thread_id),
                        content: Set(cmd.content.clone()),
                        created_at: Set(now),
                        updated_at: Set(now),
                    }
                    .insert(self.database.write())
                    .await?;
                }
            }
        }

        Ok(DraftDto {
            room_id,
            thread_id: cmd.thread_id,
            content: cmd.content,
            updated_at: now,
        })
    }

    pub async fn get_draft(
        &self,
        caller: i64,
        room_id: Uuid,
        thread_id: Option<Uuid>,
    ) -> Result<Option<DraftDto>, ChatError> {
        let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
        let rows = user_drafts::Entity::find()
            .filter(user_drafts::Column::UserId.eq(caller))
            .filter(user_drafts::Column::RoomId.eq(room_id))
            .all(self.database.read())
            .await?;
        Ok(rows
            .into_iter()
            .find(|r| r.thread_id == thread_id)
            .map(|r| DraftDto {
                room_id,
                thread_id: r.thread_id,
                content: r.content,
                updated_at: r.updated_at,
            }))
    }

    pub async fn delete_draft(
        &self,
        caller: i64,
        room_id: Uuid,
        thread_id: Option<Uuid>,
    ) -> Result<(), ChatError> {
        let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
        let mut q = user_drafts::Entity::delete_many()
            .filter(user_drafts::Column::UserId.eq(caller))
            .filter(user_drafts::Column::RoomId.eq(room_id));
        if let Some(tid) = thread_id {
            q = q.filter(user_drafts::Column::ThreadId.eq(tid));
        }
        let deleted = q.exec(self.database.write()).await?;
        if deleted.rows_affected == 0 {
            return Err(ChatError::NotFound);
        }
        Ok(())
    }

    pub async fn list_my_drafts(&self, caller: i64) -> Result<Vec<DraftDto>, ChatError> {
        let rows = user_drafts::Entity::find()
            .filter(user_drafts::Column::UserId.eq(caller))
            .all(self.database.read())
            .await?;
        Ok(rows
            .into_iter()
            .map(|r| DraftDto {
                room_id: r.room_id,
                thread_id: r.thread_id,
                content: r.content,
                updated_at: r.updated_at,
            })
            .collect())
    }
}