use log::info;

use sqlx::{
    mysql::MySqlPoolOptions,
    postgres::PgPoolOptions,
};

fn setup_logger() -> Result<(), fern::InitError> {
    fern::Dispatch::new()
        .format(|out, message, record| {
            out.finish(format_args!(
                "{}[{}][{}] {}",
                chrono::Local::now().format("[%Y-%m-%d][%H:%M:%S]"),
                record.target(),
                record.level(),
                message
            ))
        })
        .level(log::LevelFilter::Debug)
        .chain(std::io::stdout())
        .chain(fern::log_file("output.log")?)
        .apply()?;
    Ok(())
}

async fn check_maria_db() -> Result<(), sqlx::Error> {
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://demo_user:demo_pass@localhost:8084/demo")
        .await?;

    // Make a simple query to return the given parameter
    let row = sqlx::query("SELECT * from events")
        .fetch_all(&pool)
        .await?;

    info!("Received {:?}", row);

    Ok(())
}

// async fn check_ms_sql() -> Result<(), sqlx::Error> {
//     let pool = MySqlPoolOptions::new()
//         .max_connections(5)
//         .connect("mssql://sa:'adm1n_pa%s'@localhost:8085/demo")
//         .await?;

//     // Make a simple query to return the given parameter
//     let row = sqlx::query("SELECT * from events")
//         .fetch_all(&pool)
//         .await?;

//     info!("Received {:?}", row);

//     Ok(())
// }

async fn check_mysql() -> Result<(), sqlx::Error> {
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://demo_user:demo_pass@localhost:8086/demo")
        .await?;

    // Make a simple query to return the given parameter
    let row = sqlx::query("SELECT * from events")
        .fetch_all(&pool)
        .await?;

    info!("Received {:?}", row);

    Ok(())
}

async fn check_postgres() -> Result<(), sqlx::Error> {
    // Create a connection pool
    //  for MySQL, use MySqlPoolOptions::new()
    //  for SQLite, use SqlitePoolOptions::new()
    //  etc.
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://demo_user:demo_pass@localhost:8087/demo")
        .await?;

    // Make a simple query to return the given parameter
    let row: (i64,) = sqlx::query_as("SELECT $1")
        .bind(150_i64)
        .fetch_one(&pool)
        .await?;

    assert_eq!(row.0, 150);

    info!("Received {}", row.0);

    Ok(())
}

//#[async_std::main]
#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    setup_logger().unwrap();

    let ts = vec![
        tokio::spawn(async move {
            check_postgres().await.unwrap();
        }),
        tokio::spawn(async move {
            check_mysql().await.unwrap();
        }),
        // tokio::spawn(async move {
        //     check_ms_sql().await.unwrap();
        // }),
        tokio::spawn(async move {
            check_maria_db().await.unwrap();
        }),
    ];

    info!("---- Spawned all ----");

    for t in ts {
        t.await.unwrap();
    }

    Ok(())
}