use async_trait::async_trait;
use sea_orm::{EntityTrait, IntoActiveModel, PrimaryKeyTrait};
use std::fmt::Debug;

use crate::error::DatabaseError;

#[async_trait]
pub trait Repository<T>
where
    T: EntityTrait + Clone + Debug + Send + Sync,
    T::Model: IntoActiveModel<T::ActiveModel> + Send + Sync,
    T::ActiveModel: Send,
    i64: Into<<<T as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>,
{
    async fn create(&self, data: &T::Model) -> Result<(), DatabaseError>;

    async fn update(&self, data: &T::Model) -> Result<(), DatabaseError>;
  
    async fn delete(&self, data: &T::Model) -> Result<(), DatabaseError>;
  
    async fn delete_by_id(&self, id: i64) -> Result<(), DatabaseError>;

    async fn delete_by_ids(&self, ids: Vec<i64>) -> Result<(), DatabaseError>;
   
    async fn find_by_id(&self, id: i64) -> Result<Option<T::Model>, DatabaseError>;
    
    async fn find_by_ids(&self, ids: Vec<i64>) -> Result<Vec<T::Model>, DatabaseError>;

    async fn find_with_pagination(
        &self,
        page: u64,
        page_size: u64,
    ) -> Result<(Vec<T::Model>, u64), DatabaseError>;

    async fn find_by_field<V>(&self, field: &str, value: V) -> Result<Vec<T::Model>, DatabaseError>
    where
        V: Into<sea_orm::Value> + Send + Sync;
}

use super::repository::Repository;
use crate::error::DatabaseError;
use async_trait::async_trait;
use sea_orm::prelude::Expr;
use sea_orm::sea_query::Alias;
use sea_orm::{Condition, QueryFilter, Value};
use sea_orm::{
    DatabaseConnection, EntityTrait, IntoActiveModel, PaginatorTrait, PrimaryKeyTrait,
    TransactionTrait,
};

use std::{fmt::Debug, marker::PhantomData};

pub struct EntityRepository<T> {
    conn: DatabaseConnection,
    _phantom: PhantomData<T>, 
}

impl<T> EntityRepository<T> {
    pub fn new(conn: DatabaseConnection) -> Self {
        Self {
            conn,
            _phantom: PhantomData,
        }
    }
}

#[async_trait]
impl<T> Repository<T> for EntityRepository<T>
where
    T: EntityTrait + Clone + Debug + Send + Sync,
    T::Model: IntoActiveModel<T::ActiveModel> + Send + Sync,
    T::ActiveModel: Send,
    i64: Into<<<T as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>,
{
    async fn create(&self, data: &T::Model) -> Result<(), DatabaseError> {
        let model = data.clone().into_active_model();
        T::insert(model)
            .exec(&self.conn)
            .await
            .map_err(|e: sea_orm::DbErr| DatabaseError::CreateError(e))?;
        Ok(())
    }

    async fn update(&self, data: &T::Model) -> Result<(), DatabaseError> {
        let model = data.clone().into_active_model();
        T::update(model)
            .exec(&self.conn)
            .await
            .map_err(|e: sea_orm::DbErr| DatabaseError::UpdateError(e))?;
        Ok(())
    }

    async fn delete(&self, data: &T::Model) -> Result<(), DatabaseError> {
        let model = data.clone().into_active_model();
        T::delete(model)
            .exec(&self.conn)
            .await
            .map_err(|e: sea_orm::DbErr| DatabaseError::DeleteError(e))?;
        Ok(())
    }

    async fn delete_by_id(&self, id: i64) -> Result<(), DatabaseError> {
        T::delete_by_id(id)
            .exec(&self.conn)
            .await
            .map_err(|e| DatabaseError::DeleteError(e))?;
        Ok(())
    }

    async fn delete_by_ids(&self, ids: Vec<i64>) -> Result<(), DatabaseError> {
        let txn = self
            .conn
            .begin()
            .await
            .map_err(|e| DatabaseError::RollbackError(e))?;

        for id in ids {
            T::delete_by_id(id)
                .exec(&txn)
                .await
                .map_err(|e| DatabaseError::RollbackError(e))?;
        }

        txn.commit()
            .await
            .map_err(|e| DatabaseError::RollbackError(e))?;

        Ok(())
    }

    async fn find_by_id(&self, id: i64) -> Result<Option<T::Model>, DatabaseError> {
        let result = T::find_by_id(id)
            .one(&self.conn)
            .await
            .map_err(|e| DatabaseError::ReadError(e))?;
        Ok(result)
    }

    async fn find_by_ids(&self, ids: Vec<i64>) -> Result<Vec<T::Model>, DatabaseError> {
        let mut result = Vec::new();

        for id in ids {
            if let Some(model) = T::find_by_id(id)
                .one(&self.conn)
                .await
                .map_err(|e| DatabaseError::ReadError(e))?
            {
                result.push(model);
            }
        }

        Ok(result)
    }


    async fn find_with_pagination(
        &self,
        page: u64,
        page_size: u64,
    ) -> Result<(Vec<T::Model>, u64), DatabaseError> {
        let paginator = T::find().paginate(&self.conn, page_size);
        let num_pages = paginator
            .num_pages()
            .await
            .map_err(|e| DatabaseError::PaginationError(e))?;
        // Fetch paginated posts
        let result = paginator
            .fetch_page(page - 1)
            .await
            .map(|p| (p, num_pages))
            .map_err(|e| DatabaseError::PaginationError(e))?;
        Ok(result)
    }


    async fn find_by_field<V>(&self, field: &str, value: V) -> Result<Vec<T::Model>, DatabaseError>
    where
        V: Into<Value> + Send + Sync,
    {
        let value_expr = value.into();
        let result = T::find()
            .filter(Condition::any().add(Expr::col(Alias::new(field)).eq(value_expr)))
            .all(&self.conn)
            .await
            .map_err(|e| DatabaseError::ReadByFieldError(e))?;

        Ok(result)
    }
}

let repo: EntityRepository<test_entity::Entity> = EntityRepository::new(db);

let entity = test_entity::Model {
     id: 1,
     name: "Updated Entity".to_string(),
     description: Some("Updated Description".to_string()),
     created_at: Utc::now(),
     updated_at: Utc::now(),
 };

let result = repo.update(&entity).await;
assert!(result.is_ok());