use textsender_auth;
use textsender_auth::callers;
use textsender_auth::db;
use textsender_auth::init;

mod db_mgr {
    use std::str::FromStr;

    pub const LIMIT: usize = 6;

    pub async fn get_pool() -> Result<sqlx::PgPool, sqlx::Error> {
        let tm_db_url = textsender_models::envy::environment::get_db_url()
            .await
            .value;
        let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
        sqlx::PgPool::connect_with(tm_options).await
    }

    pub async fn generate_db_name() -> String {
        let db_name =
            get_database_name().await.unwrap() + &"_" + &uuid::Uuid::new_v4().to_string()[..LIMIT];
        db_name
    }

    pub async fn connect_to_db(db_name: &str) -> Result<sqlx::PgPool, sqlx::Error> {
        let db_url = textsender_models::envy::environment::get_db_url()
            .await
            .value;
        let options = sqlx::postgres::PgConnectOptions::from_str(&db_url)?.database(db_name);
        sqlx::PgPool::connect_with(options).await
    }

    pub async fn create_database(
        template_pool: &sqlx::PgPool,
        db_name: &str,
    ) -> Result<(), sqlx::Error> {
        let create_query = format!("CREATE DATABASE {}", db_name);
        match sqlx::query(&create_query).execute(template_pool).await {
            Ok(_) => Ok(()),
            Err(e) => Err(e),
        }
    }

    // Function to drop a database
    pub async fn drop_database(
        template_pool: &sqlx::PgPool,
        db_name: &str,
    ) -> Result<(), sqlx::Error> {
        let drop_query = format!("DROP DATABASE IF EXISTS {} WITH (FORCE)", db_name);
        sqlx::query(&drop_query).execute(template_pool).await?;
        Ok(())
    }

    pub async fn get_database_name() -> Result<String, Box<dyn std::error::Error>> {
        let database_url = textsender_models::envy::environment::get_db_url()
            .await
            .value;

        let parsed_url = url::Url::parse(&database_url)?;
        if parsed_url.scheme() == "postgres" || parsed_url.scheme() == "postgresql" {
            match parsed_url
                .path_segments()
                .and_then(|segments| segments.last().map(|s| s.to_string()))
            {
                Some(sss) => Ok(sss),
                None => Err("Error parsing".into()),
            }
        } else {
            // Handle other database types if needed
            Err("Error parsing".into())
        }
    }
}

pub mod requests {
    use tower::ServiceExt; // for `call`, `oneshot`, and `ready`

    pub async fn register_user(
        app: &axum::Router,
    ) -> Result<axum::response::Response, std::convert::Infallible> {
        let payload = serde_json::json!({
            "username": String::from(super::TEST_USERNAME),
            "password": String::from(super::TEST_PASSWORD),
            "phone_number": String::from(super::TEST_PHONE_NUMBER),
            "firstname": String::from(super::TEST_FIRSTNAME),
            "lastname": String::from(super::TEST_LASTNAME),
        });
        let req = axum::http::Request::builder()
            .method(axum::http::Method::POST)
            .uri(super::callers::endpoints::LOGIN)
            .header(axum::http::header::CONTENT_TYPE, "application/json")
            .body(axum::body::Body::from(payload.to_string()))
            .unwrap();

        app.clone().oneshot(req).await
    }
}

#[test]
fn test_demo() {
    let i = 0;

    assert_eq!(0, i, "Values should match {} {}", 0, 1);
}

const TEST_FIRSTNAME: &str = "Billy";
const TEST_LASTNAME: &str = "Bob";
const TEST_USERNAME: &str = "BillyBob01";
const TEST_PASSWORD: &str = "923ndcry392qryudx328qrdy328r";
const TEST_PHONE_NUMBER: &str = "+10123456789";

#[tokio::test]
async fn test_register_user() {
    let tm_pool = db_mgr::get_pool().await.unwrap();
    let db_name = db_mgr::generate_db_name().await;

    match db_mgr::create_database(&tm_pool, &db_name).await {
        Ok(_) => {
            println!("Success");
        }
        Err(e) => {
            assert!(false, "Error: {:?}", e.to_string());
        }
    }

    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();

    db::init::migrations(&pool).await;

    let app = init::routes().await.layer(axum::Extension(pool));

    match requests::register_user(&app).await {
        Ok(response) => {
            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
                .await
                .unwrap();
            let parsed_body: callers::register::response::Response =
                serde_json::from_slice(&body).unwrap();
            assert!(parsed_body.data.len() > 0, "No data found");
            let returned_user = &parsed_body.data[0];
            assert_eq!(
                TEST_USERNAME, returned_user.username,
                "Error with returned user"
            );
        }
        Err(err) => {
            assert!(false, "Error: {err:?}");
        }
    }

    match db_mgr::drop_database(&tm_pool, &db_name).await {
        Ok(()) => {}
        Err(err) => {
            assert!(false, "Error: {err:?}");
        }
    }
}

#[tokio::test]
async fn test_login_user() {
}