use crate::error::{handle_error, Error};
use sqlx::sqlite::SqliteQueryResult;
use sqlx::types::chrono::{DateTime, Utc};
use sqlx::{FromRow, SqliteExecutor};

#[derive(FromRow)]
pub struct Permissions {
    pub user: String,
    pub role: String,
    pub created_at: DateTime<Utc>,
}

impl Permissions {
    pub async fn get_all(
        conn: impl SqliteExecutor<'_>,
        user: Option<&str>,
        role: Option<&str>,
    ) -> Result<Vec<Self>, Error> {
        match (user, role) {
            (Some(user), Some(role)) => {
                // Get all for user and role
                sqlx::query_file_as!(
                    Self,
                    "queries/permissions/get_all_user_role.sql",
                    user,
                    role
                )
                .fetch_all(conn)
                .await
                .map_err(handle_error)
            }
            (Some(user), None) => {
                // Get all for user
                sqlx::query_file_as!(Self, "queries/permissions/get_all_user.sql", user)
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
            (None, Some(role)) => {
                // Get all for role
                sqlx::query_file_as!(Self, "queries/permissions/get_all_role.sql", role)
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
            (None, None) => {
                // Get all permissions
                sqlx::query_file_as!(Self, "queries/permissions/get_all.sql")
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
        }
    }

    pub async fn add(
        conn: impl SqliteExecutor<'_>,
        user: &str,
        role: &str,
    ) -> Result<Option<()>, Error> {
        let query: SqliteQueryResult = sqlx::query_file!("queries/permissions/add.sql", user, role)
            .execute(conn)
            .await
            .map_err(handle_error)?;

        Ok((query.rows_affected() == 1).then_some(()))
    }

    pub async fn delete(
        conn: impl SqliteExecutor<'_>,
        user: &str,
        role: &str,
    ) -> Result<Option<()>, Error> {
        let query: SqliteQueryResult =
            sqlx::query_file!("queries/permissions/delete.sql", user, role)
                .execute(conn)
                .await
                .map_err(handle_error)?;

        Ok((query.rows_affected() == 1).then_some(()))
    }
}