use async_trait::async_trait;
use chrono::{DateTime, Utc};
use sqlx::PgPool;
use domain::{errors::DomainError, models::social::Like, ports::LikeRepository, value_objects::{LikeId, ThoughtId, UserId}};

pub struct PgLikeRepository { pool: PgPool }
impl PgLikeRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }

#[async_trait]
impl LikeRepository for PgLikeRepository {
    async fn save(&self, l: &Like) -> Result<(), DomainError> {
        sqlx::query(
            "INSERT INTO likes(id,user_id,thought_id,ap_id,created_at) VALUES($1,$2,$3,$4,$5) ON CONFLICT(user_id,thought_id) DO NOTHING"
        )
        .bind(l.id.as_uuid()).bind(l.user_id.as_uuid()).bind(l.thought_id.as_uuid()).bind(&l.ap_id).bind(l.created_at)
        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
    }

    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
        let r = sqlx::query("DELETE FROM likes WHERE user_id=$1 AND thought_id=$2")
            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
        Ok(())
    }

    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Like>, DomainError> {
        #[derive(sqlx::FromRow)]
        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, thought_id: uuid::Uuid, ap_id: Option<String>, created_at: DateTime<Utc> }
        sqlx::query_as::<_, Row>("SELECT id,user_id,thought_id,ap_id,created_at FROM likes WHERE user_id=$1 AND thought_id=$2")
            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
            .fetch_optional(&self.pool).await
            .map_err(|e| DomainError::Internal(e.to_string()))
            .map(|o| o.map(|r| Like { id: LikeId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), thought_id: ThoughtId::from_uuid(r.thought_id), ap_id: r.ap_id, created_at: r.created_at }))
    }

    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
        sqlx::query_scalar("SELECT COUNT(*) FROM likes WHERE thought_id=$1")
            .bind(thought_id.as_uuid()).fetch_one(&self.pool).await
            .map_err(|e| DomainError::Internal(e.to_string()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use domain::{models::{thought::{Thought, Visibility}, user::User}, value_objects::*};
    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
    use domain::ports::{ThoughtRepository, UserRepository};

    async fn seed(pool: &sqlx::PgPool) -> (User, Thought) {
        let urepo = PgUserRepository::new(pool.clone());
        let trepo = PgThoughtRepository::new(pool.clone());
        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
        urepo.save(&u).await.unwrap();
        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local("hi").unwrap(), None, Visibility::Public, None, false);
        trepo.save(&t).await.unwrap();
        (u, t)
    }

    #[sqlx::test(migrations = "./migrations")]
    async fn like_and_count(pool: sqlx::PgPool) {
        let (user, thought) = seed(&pool).await;
        let repo = PgLikeRepository::new(pool);
        let like = Like { id: LikeId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
        repo.save(&like).await.unwrap();
        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
    }

    #[sqlx::test(migrations = "./migrations")]
    async fn unlike(pool: sqlx::PgPool) {
        let (user, thought) = seed(&pool).await;
        let repo = PgLikeRepository::new(pool);
        let like = Like { id: LikeId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
        repo.save(&like).await.unwrap();
        repo.delete(&user.id, &thought.id).await.unwrap();
        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
    }
}