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

#[derive(FromRow)]
pub struct Keys {
    pub id: String,
    pub created_at: DateTime<Utc>,
    pub revoked_at: Option<DateTime<Utc>>,
    pub private_der: Vec<u8>,
    pub public_der: Vec<u8>,
}

impl Keys {
    pub async fn insert(
        conn: impl SqliteExecutor<'_>,
        id: &str,
        private_der: &[u8],
        public_der: &[u8],
    ) -> Result<Option<()>, Error> {
        let query: SqliteQueryResult =
            sqlx::query_file!("queries/keys/insert.sql", id, private_der, public_der)
                .execute(conn)
                .await
                .map_err(handle_error)?;

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

    pub async fn get_most_recent(conn: impl SqliteExecutor<'_>) -> Result<Option<Self>, Error> {
        sqlx::query_file_as!(Self, "queries/keys/get_most_recent.sql")
            .fetch_optional(conn)
            .await
            .map_err(handle_error)
    }

    pub async fn get_all(
        conn: impl SqliteExecutor<'_>,
        filter_get_revoked: Option<bool>,
    ) -> Result<Vec<Self>, Error> {
        match filter_get_revoked {
            Some(true) => {
                // Get all revoked keys
                sqlx::query_file_as!(Self, "queries/keys/get_all_revoked.sql")
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
            Some(false) => {
                // Get all valid keys
                sqlx::query_file_as!(Self, "queries/keys/get_all_valid.sql")
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
            None => {
                // Get all keys
                sqlx::query_file_as!(Self, "queries/keys/get_all.sql")
                    .fetch_all(conn)
                    .await
                    .map_err(handle_error)
            }
        }
    }

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

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