pub use account_orders::*;
pub use accounts::*;
use actix::{Actor, Context};
pub use order_items::*;
pub use products::*;
pub use shopping_cart_items::*;
pub use shopping_carts::*;
use sqlx::PgPool;
pub use stocks::*;
pub use tokens::*;

pub mod account_orders;
pub mod accounts;
pub mod order_items;
pub mod products;
pub mod shopping_cart_items;
pub mod shopping_carts;
pub mod stocks;
pub mod tokens;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Failed to connect to database. {0:?}")]
    Connect(#[from] sqlx::Error),
    #[error("{0}")]
    Account(#[from] accounts::Error),
    #[error("{0}")]
    AccountOrder(#[from] account_orders::Error),
    #[error("{0}")]
    Product(#[from] products::Error),
    #[error("{0}")]
    Stock(#[from] stocks::Error),
    #[error("{0}")]
    OrderItem(#[from] order_items::Error),
    #[error("{0}")]
    ShoppingCart(#[from] shopping_carts::Error),
    #[error("{0}")]
    ShoppingCartItem(#[from] shopping_cart_items::Error),
    #[error("{0}")]
    Token(#[from] tokens::Error),
}

pub type Result<T> = std::result::Result<T, Error>;

pub struct Database {
    pool: PgPool,
}

impl Clone for Database {
    fn clone(&self) -> Self {
        Self {
            pool: self.pool.clone(),
        }
    }
}

impl Database {
    pub(crate) async fn build(url: &str) -> Result<Self> {
        let pool = sqlx::PgPool::connect(url).await.map_err(Error::Connect)?;
        Ok(Database { pool })
    }

    pub fn pool(&self) -> &PgPool {
        &self.pool
    }
}

impl Actor for Database {
    type Context = Context<Self>;
}