use clap::ValueEnum;
use sea_schema::postgres::discovery::SchemaDiscovery;
use sqlx::PgPool;
use url::Url;

use crate::error::{Error, Result};

use self::schema::SchemaDefinition;

mod postgres;
mod schema;

#[derive(ValueEnum, Clone)]
pub enum Database {
    Postgres,
}

async fn get_connector(url: &String) -> Result<(postgres::PgConnector, String)> {
    let parse = Url::parse(url)?;
    let scheme = parse.scheme();

    let connector = match scheme {
        "postgresql" => postgres::PgConnector::new(url.to_owned()).await?,
        &_ => {
            return Err(Error::Generic(format!(
                "Database `{}` is not supported",
                scheme
            )))
        }
    };
    Ok((connector, scheme.to_owned()))
}

pub async fn handle_query(url: String, query: &String) -> Result<()> {
    let (connector, _) = get_connector(&url).await?;

    let rows = connector.query(query).await?;

    for (idx, row) in rows.iter().enumerate() {
        println!("Row {}: {:?}", idx, row);
    }

    return Ok(());
}

pub async fn discover_scheme(url: String, schema: Option<String>) -> Result<()> {
    let (_, db_name) = get_connector(&url).await?;

    let schema_discovery = match db_name.as_str() {
        "postgresql" => {
            let schema = schema.unwrap_or("public".to_owned());
            let pool = PgPool::connect(url.as_str()).await?;
            SchemaDiscovery::new(pool, schema.as_str())
        }
        &_ => {
            return Err(Error::Generic(format!(
                "Database `{}` is not supported",
                db_name
            )))
        }
    };

    let schema = schema_discovery.discover().await?;

    let schema_definition = SchemaDefinition::from(schema);

    println!("{}", schema_definition);

    Ok(())
}