pub mod methods;
use dotenv::dotenv;
use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
use sqlx::{Error, Pool, Sqlite};
use std::env;
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
use tide::prelude::*;

#[derive(Debug, Deserialize, Serialize, sqlx::FromRow)]
pub struct AccountsPending {
    user: String,
    mail: String,
    name_first : String,
    name_second : String,
    auth_code : String,
    discord: Option<String>,
    // will only last for a few hours
    expiry: i64
}

pub async fn db_init(database: &str) -> Result<Pool<Sqlite>, Error> {
    let pool = SqlitePoolOptions::new()
        .max_connections(5)
        .connect_with(SqliteConnectOptions::from_str(&format!("sqlite://{}", database))?.create_if_missing(true))
        .await?;

    sqlx::query(
        "CREATE TABLE IF NOT EXISTS accounts_pending (
            user text primary key,
            mail text not null,
            name_first text not null,
            name_second text not null,
            auth_code text not null,
            discord text,
            expiry integer not null
         )",
    )
    .execute(&pool)
    .await?;

    // set up indexes?
    /*
    sqlx::query("CREATE INDEX IF NOT EXISTS index_estimate ON bus_results (valid_estimate)")
        .execute(&pool)
        .await?;
    */
    Ok(pool)
}

pub fn get_now() -> i64 {
    if let Ok(x) = SystemTime::now().duration_since(UNIX_EPOCH) {
        x.as_secs() as i64
    } else {
        0
    }
}

#[derive(Clone)]
pub struct State {
    pub db: Pool<Sqlite>,
    pub config: Config,
}

#[derive(Debug, Clone)]
pub struct Config {
    ldap_host: String,
    ldap_admin: String,
    ldap_admin_pw: String,
    pub database: String,
    pub host_port: String,
}

pub fn get_config() -> Config {
    dotenv().ok();

    // reasonable defaults
    let mut config = Config {
        ldap_host: "".to_string(),
        ldap_admin: "".to_string(),
        ldap_admin_pw: "".to_string(),
        database: "database.db".to_string(),
        host_port: "127.0.0.1:8087".to_string(),
    };

    if let Ok(x) = env::var("LDAP_HOST") {
        config.ldap_host = x.trim().to_string();
    }
    if let Ok(x) = env::var("LDAP_ADMIN") {
        config.ldap_admin = x.trim().to_string();
    }
    if let Ok(x) = env::var("LDAP_ADMIN_PW") {
        config.ldap_admin_pw = x.trim().to_string();
    }
    if let Ok(x) = env::var("DATABASE") {
        config.database = x.trim().to_string();
    }
    if let Ok(x) = env::var("HOST_PORT") {
        config.host_port = x.trim().to_string();
    }

    config
}