use crate::error::Error;
use crate::RefreshToken;
use chrono::{Duration, Utc};
use database::sqlx::SqliteExecutor;
use database::RefreshTokens as DatabaseRefreshTokens;
use id::{AppID, UserID};

impl From<DatabaseRefreshTokens> for RefreshToken {
    fn from(db: DatabaseRefreshTokens) -> Self {
        Self {
            // Info
            token: db.token,
            ip_address: db.ip_address,
            user: UserID(db.user),
            app: AppID(db.app),

            // Timings
            created_at: db.created_at,
            expires_at: db.expires_at,
            used_at: db.used_at,
            revoked_at: db.revoked_at,
        }
    }
}

impl RefreshToken {
    pub async fn insert(
        conn: impl SqliteExecutor<'_>,
        token: &str,
        ip_address: String,
        user: &UserID,
        app: &AppID,
        duration_days: i64,
    ) -> Result<Option<()>, Error> {
        let expires_at = Utc::now() + Duration::days(duration_days);

        Ok(DatabaseRefreshTokens::insert(
            conn,
            token,
            ip_address.as_str(),
            user.as_ref(),
            app.as_ref(),
            expires_at.timestamp(),
        )
        .await?)
    }

    pub async fn get_one(
        conn: impl SqliteExecutor<'_>,
        token: &str,
    ) -> Result<Option<Self>, Error> {
        Ok(DatabaseRefreshTokens::get_one(conn, token)
            .await?
            .map(Self::from))
    }

    pub async fn revoke(self, conn: impl SqliteExecutor<'_>) -> Result<Option<()>, Error> {
        Ok(DatabaseRefreshTokens::revoke(conn, &self.token).await?)
    }

    pub async fn revoke_all(conn: impl SqliteExecutor<'_>) -> Result<Option<()>, Error> {
        Ok(DatabaseRefreshTokens::revoke_all(conn).await?)
    }

    pub async fn revoke_all_for_user(
        conn: impl SqliteExecutor<'_>,
        user: &UserID,
    ) -> Result<Option<()>, Error> {
        Ok(DatabaseRefreshTokens::revoke_all_for_user(conn, user.as_ref()).await?)
    }

    pub async fn use_token(&self, conn: impl SqliteExecutor<'_>) -> Result<Option<()>, Error> {
        Ok(DatabaseRefreshTokens::use_token(conn, &self.token).await?)
    }
}