use anyhow::Result;
use chrono::{DateTime, Utc};
use sqlx::FromRow;

use crate::repo::Storage;

impl Storage {
    pub async fn retrieve_dialog(&self, participant_1: &str, participant_2: &str) -> Result<Option<StoredDialog>> {
        let mut executor = self.conn.lock().await;
        let res = sqlx::query_as(
            "select r.id, r.participant_1, r.participant_2, r.message_count
            from dialogs r join users u1 on r.participant_1 = u1.id join users u2 on r.participant_2 = u2.id
            where u1.name = ? and u2.name = ?;",
        )
        .bind(participant_1)
        .bind(participant_2)
        .fetch_optional(&mut *executor)
        .await?;

        Ok(res)
    }

    pub async fn increment_dialog_message_count(&self, storage_id: u32) -> Result<()> {
        let mut executor = self.conn.lock().await;
        sqlx::query(
            "update rooms set message_count = message_count + 1
            where id = ?;",
        )
        .bind(storage_id)
        .execute(&mut *executor)
        .await?;

        Ok(())
    }

    pub async fn initialize_dialog(
        &self,
        participant_1: &str,
        participant_2: &str,
        created_at: &DateTime<Utc>,
    ) -> Result<StoredDialog> {
        let mut executor = self.conn.lock().await;
        let res: StoredDialog = sqlx::query_as(
            "insert into dialogs(participant_1, participant_2, created_at)
            values (
                (select id from users where name = ?),
                (select id from users where name = ?),
                ?
            )
            returning id, participant_1, participant_2, message_count;",
        )
        .bind(participant_1)
        .bind(participant_2)
        .bind(&created_at)
        .fetch_one(&mut *executor)
        .await?;

        Ok(res)
    }
}

#[derive(FromRow)]
pub struct StoredDialog {
    pub id: u32,
    pub participant_1: u32,
    pub participant_2: u32,
    pub message_count: u32,
}