use chrono::{DateTime, Utc};
use database::sqlx::SqliteExecutor;
use database::Settings as DatabaseSettings;

// error
#[derive(thiserror::Error)]
// the rest
#[derive(Debug)]
pub enum Error {
    #[error("Database: {0}")]
    Database(#[from] database::Error),
}

// the rest
#[derive(Debug)]
pub struct Settings {
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
    business_name: String,
    business_logo: Vec<u8>,
}

const DEFAULT_BUSINESS_NAME: &str = "ezidam";
const DEFAULT_BUSINESS_LOGO: &[u8] = include_bytes!("../../../logo/ezidam.png");

impl From<DatabaseSettings> for Settings {
    fn from(db: DatabaseSettings) -> Self {
        Self {
            created_at: db.created_at,
            updated_at: db.updated_at,
            business_name: db
                .business_name
                .unwrap_or_else(|| DEFAULT_BUSINESS_NAME.into()),
            business_logo: db
                .business_logo
                .unwrap_or_else(|| DEFAULT_BUSINESS_LOGO.to_vec()),
        }
    }
}

impl Settings {
    pub fn business_logo(&self) -> &[u8] {
        self.business_logo.as_slice()
    }
}

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

    pub async fn get(conn: impl SqliteExecutor<'_>) -> Result<Self, Error> {
        Ok(DatabaseSettings::get(conn).await.map(Self::from)?)
    }

    pub async fn set_business_name(
        conn: impl SqliteExecutor<'_>,
        business_name: &str,
    ) -> Result<(), Error> {
        DatabaseSettings::set_business_name(conn, Some(business_name)).await?;

        Ok(())
    }

    /// **Warning**: No checks are performed, make sure the bytes are safe!
    pub async fn set_business_logo(
        conn: impl SqliteExecutor<'_>,
        business_logo: &[u8],
    ) -> Result<(), Error> {
        DatabaseSettings::set_business_logo(conn, Some(business_logo)).await?;

        Ok(())
    }
}