use std::sync::Arc;

use async_sqlx_session::PostgresSessionStore;
use como_auth::{AuthService, SessionService};
use como_core::{items::DynItemService, projects::DynProjectService, users::DynUserService};
use tracing::log::info;

use crate::{
    configs::{AppConfig, DatabaseType},
    database::ConnectionPool,
    services::{
        item_service::{DefaultItemService, MemoryItemService},
        project_service::{DefaultProjectService, MemoryProjectService},
        user_service::DefaultUserService,
    },
};

#[derive(Clone)]
pub struct ServiceRegister {
    pub item_service: DynItemService,
    pub project_service: DynProjectService,
    pub user_service: DynUserService,
    pub session_store: PostgresSessionStore,
    pub auth_service: AuthService,
}

impl ServiceRegister {
    pub async fn new(pool: ConnectionPool, config: Arc<AppConfig>) -> anyhow::Result<Self> {
        info!("creating services");

        let session = SessionService::new(&config.auth).await?;
        let auth = AuthService::new(&config.auth, session).await?;

        let s = match config.database_type {
            DatabaseType::Postgres => {
                let item_service =
                    Arc::new(DefaultItemService::new(pool.clone())) as DynItemService;
                let project_service =
                    Arc::new(DefaultProjectService::new(pool.clone())) as DynProjectService;
                let user_service =
                    Arc::new(DefaultUserService::new(pool.clone())) as DynUserService;
                let store = PostgresSessionStore::new(&config.database_url).await?;
                store.migrate().await?;

                Self {
                    item_service,
                    user_service,
                    project_service,
                    session_store: store,
                    auth_service: auth,
                }
            }
            DatabaseType::InMemory => {
                let item_service = Arc::new(MemoryItemService::new()) as DynItemService;
                let project_service = Arc::new(MemoryProjectService::new()) as DynProjectService;
                let user_service =
                    Arc::new(DefaultUserService::new(pool.clone())) as DynUserService;
                let store = PostgresSessionStore::new(&config.database_url).await?;
                store.migrate().await?;

                Self {
                    item_service,
                    user_service,
                    project_service,
                    session_store: store,
                    auth_service: auth,
                }
            }
        };
        info!("services created succesfully");

        Ok(s)
    }
}