use chrono::{DateTime, SecondsFormat, Utc};
use skynet_ldap_backend::{get_config, Config, db_init, Accounts, AccountsNew};
use std::error::Error;
use sqlx::{Pool, Sqlite};
use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;
use lettre::{
    message::{header, MultiPart, SinglePart},
    SmtpTransport, Message, Transport,
    transport::smtp::{
        authentication::Credentials, 
        response::Response
    },
};
use maud::html;

#[async_std::main]
async fn main() {
    let config = get_config();
    let db = db_init(&config).await.unwrap();
    let now = Utc::now();

    if let Ok(records) = read_csv(&config){
        for record in records {
            // check if the email is already in the db
            if !check(&db, &record.email).await {
                continue;
            }
            
            // generate a auth key
            let auth = generate_auth();
          
            match send_mail(&config, &record, &auth) {
              Ok(_) => {
                match save_to_db(&db, now, &record, &auth).await {
                  Ok(_) => {}
                  Err(e) => {
                    println!("Unable to save to db {}  {e:?}", &record.email);
                  }
                }
              }
              Err(e) => {
                println!("Unable to send mail to {}  {e:?}", &record.email);
              }
            }
        }
    }
}


#[derive(Debug, serde::Deserialize)]
struct Record {
    #[serde(rename = "MemID")]
    mem_id: String,
    #[serde(rename = "Student Num")]
    id_student: String,
    #[serde(rename = "Contact Email")]
    email: String,
    #[serde(rename = "Expiry")]
    expiry: String,
    #[serde(rename = "First Name")]
    name_first: String,
    #[serde(rename = "Last Name")]
    name_second: String,
}

fn read_csv(config: &Config) -> Result<Vec<Record>, Box<dyn Error>> {
    let mut records: Vec<Record> = vec![];

    if let Ok(mut rdr) = csv::Reader::from_path(format!("{}/{}", &config.home, &config.csv)) {
        for result in rdr.deserialize() {
            // Notice that we need to provide a type hint for automatic
            // deserialization.
            let record: Record = result?;
            if record.mem_id == "" {
                continue;
            }
            records.push(record);
        }
    }

    Ok(records)
}

async fn check(db: &Pool<Sqlite>, mail: &str) -> bool {
    check_pending(db, mail).await && check_users(db, mail).await
}
async fn check_users(db: &Pool<Sqlite>, mail: &str) -> bool {
    sqlx::query_as::<_, Accounts>(
        r#"
        SELECT *
        FROM accounts
        WHERE mail == ?
        "#,
    )
      .bind(mail)
      .fetch_all(db)
      .await
      .unwrap_or(vec![])
      .is_empty()
}
async fn check_pending(db: &Pool<Sqlite>, mail: &str) -> bool {
    sqlx::query_as::<_, Accounts>(
        r#"
        SELECT *
        FROM accounts_new
        WHERE mail == ?
        "#,
    )
      .bind(mail)
      .fetch_all(db)
      .await
      .unwrap_or(vec![])
      .is_empty()
}

// from https://rust-lang-nursery.github.io/rust-cookbook/algorithms/randomness.html#create-random-passwords-from-a-set-of-alphanumeric-characters
fn generate_auth() -> String {
    thread_rng()
      .sample_iter(&Alphanumeric)
      .take(30)
      .map(char::from)
      .collect()
}

// using https://github.com/lettre/lettre/blob/57886c367d69b4d66300b322c94bd910b1eca364/examples/maud_html.rs
fn send_mail(config: &Config, record: &Record, auth: &str) -> Result<Response, lettre::transport::smtp::Error> {
    let recipient = &record.name_first;
    let mail = &record.email;
    let url_base = "https://sso.skynet.ie";
    let link_new = format!("{url_base}/register?auth={auth}");
    let link_mod = format!("{url_base}/modify");
    let discord = "https://discord.gg/mkuKJkCuyM";
    let sender = format!("UL Computer Society <{}>", &config.mail_user);

    // Create the html we want to send.
    let html = html! {
        head {
            title { "Hello from Skynet!" }
            style type="text/css" {
                "h2, h4 { font-family: Arial, Helvetica, sans-serif; }"
            }
        }
        div style="display: flex; flex-direction: column; align-items: center;" {
            h2 { "Hello from Skynet!" }
            // Substitute in the name of our recipient.
            p { "Hi " (recipient) "," }
            p { 
                "If you are a new member please use the following link:"
                br;
                a href=(link_new) { (link_new) }
            }
            p {
                "If you are a returning user please set an email for your account at:"
                br;
                a href=(link_mod) { (link_mod) }
            }
            p {
                "If you have issues please refer to our Discord server:"
                br;
                a href=(discord) { (discord) }
            }
            
            p {
                "UL Computer Society"
                br;
                "Skynet Team"
            }
        }
    };
    
    let body_text = format!(
        r#"
        Hi {recipient}
        
        If you are a new member please use the following link:
        {link_new}
        
        If you are a returning user please set an email for your account at:
        {link_mod}
        
        If you have issues please refer to our Discord server:
        {discord}
        
        UL Computer Society
        Skynet Team
        "#
    );

    // Build the message.
    let email = Message::builder()
      .from(sender.parse().unwrap())
      .to(mail.parse().unwrap())
      .subject("Skynet: New Account.")
      .multipart(
          // This is composed of two parts.
          // also helps not trip spam settings (uneven number of url's
          MultiPart::alternative() 
            .singlepart(
                SinglePart::builder()
                  .header(header::ContentType::TEXT_PLAIN)
                  .body(body_text),
            )
            .singlepart(
                SinglePart::builder()
                  .header(header::ContentType::TEXT_HTML)
                  .body(html.into_string()),
            ),
      )
      .expect("failed to build email");


    let creds = Credentials::new(config.mail_user.clone(), config.mail_pass.clone());

    // Open a remote connection to gmail using STARTTLS
    let mailer = SmtpTransport::starttls_relay(&config.mail_smtp)
      .unwrap()
      .credentials(creds)
      .build();

    // Send the email
    mailer.send(&email)
}

async fn save_to_db(db: &Pool<Sqlite>,  now: DateTime<Utc>, record: &Record, auth: &str) -> Result<Option<AccountsNew>, sqlx::Error> {
    sqlx::query_as::<_, AccountsNew>(
        "
        INSERT OR REPLACE INTO accounts_new (mail, auth_code, date_iso, date_expiry, name_first, name_surname)
        VALUES (?1, ?2, ?3, ?4, ?5, ?6)
        ",
    )
      .bind(record.email.to_owned())
      .bind(auth.to_owned())
      .bind(now.to_rfc3339_opts(SecondsFormat::Millis, true))
      .bind(record.expiry.to_owned())
      .bind(record.name_first.to_owned())
      .bind(record.name_second.to_owned())
      .fetch_optional(db)
      .await
}