pub mod config;

use std::{error::Error, sync::Arc};

pub mod guild;
pub mod trivial;
pub mod trivial_point;
pub mod trivial_question;
pub mod trivial_round;

use clickhouse_pool::{
    config::{ClickhouseConfig, DatalakeConfig, RetryConfig},
    pool_manager::PoolManager,
    traits::Model,
};
use guild::Guild;
use tracing::{error, info, instrument};
use trivial::Trivial;
use trivial_point::TrivialPoint;
use trivial_question::TrivialQuestion;
use trivial_round::TrivialRound;

use crate::config::PersistenceConfig;

pub fn create_pool_manager(db_config: PersistenceConfig) -> Result<Arc<DatalakeConfig>, String> {
    let mut config = ClickhouseConfig::new(
        db_config.host.clone(),
        db_config.port,
        db_config.database.clone(),
        db_config.user.clone(),
        db_config.password.clone(),
        10,
        30,
        5,
    );

    config.proto = "http".to_string();

    let retry_config = RetryConfig::default();

    let datalake_config = Arc::new(DatalakeConfig::new(config, retry_config));

    Ok(datalake_config)
}

#[instrument(skip(datalake_config))]
pub async fn create_manager_and_init(
    datalake_config: Arc<DatalakeConfig>,
) -> Result<Arc<PoolManager>, Box<dyn Error>> {
    let mut manager = PoolManager::new(datalake_config, None).await;

    manager = match create_table::<Trivial>(manager).await {
        Ok(manager) => manager,
        Err(e) => {
            return Err(e);
        }
    };

    manager = match create_table::<TrivialQuestion>(manager).await {
        Ok(manager) => manager,
        Err(e) => {
            return Err(e);
        }
    };

    manager = match create_table::<TrivialRound>(manager).await {
        Ok(manager) => manager,
        Err(e) => {
            return Err(e);
        }
    };

    manager = match create_table::<TrivialPoint>(manager).await {
        Ok(manager) => manager,
        Err(e) => {
            return Err(e);
        }
    };

    manager = match create_table::<Guild>(manager).await {
        Ok(manager) => manager,
        Err(e) => {
            return Err(e);
        }
    };

    info!("All tables created successfully");

    Ok(Arc::new(manager))
}

#[instrument(skip(manager))]
pub async fn create_table<T: Model>(manager: PoolManager) -> Result<PoolManager, Box<dyn Error>> {
    let _ = match manager.execute_with_retry(T::create_table_sql()).await {
        Ok(_) => {
            info!("Table {} created successfully", T::table_name());
        }
        Err(e) => {
            error!("Failed to create table {} : {}", T::table_name(), e);
            return Err(Box::new(e));
        }
    };
    Ok(manager)
}