use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, Config, ServerMembers, Servers, Wolves};

use serde::{Deserialize, Serialize};
use serenity::model::id::GuildId;
use sqlx::{Pool, Sqlite};

#[tokio::main]
async fn main() {
  let config = get_config();
  let db = match db_init(&config).await {
    Ok(x) => x,
    Err(_) => return,
  };

  // handle wolves api here
  get_wolves(&db, &config).await;
}

#[derive(Deserialize, Serialize, Debug)]
struct WolvesResultUser {
  committee: String,
  wolves_id: String,
  first_name: String,
  last_name: String,
  contact_email: String,
  student_id: Option<String>,
  note: Option<String>,
  expiry: String,
  requested: String,
  approved: String,
  sitename: String,
  domain: String,
}

#[derive(Deserialize, Serialize, Debug)]
struct WolvesResult {
  success: i8,
  result: Vec<WolvesResultUser>,
}

#[derive(Deserialize, Serialize, Debug)]
struct WolvesResultLocal {
  pub id_wolves: String,
  pub email: String,
  pub expiry: String,
}
async fn get_wolves(db: &Pool<Sqlite>, config: &Config) {
  for server_config in get_server_config_bulk(db).await {
    let Servers {
      server,
      wolves_api,
      ..
    } = server_config;

    for user in get_wolves_sub(config, &wolves_api).await {
      add_users_wolves(db, &server, &user).await;
    }
  }
}

async fn get_wolves_sub(config: &Config, wolves_api: &str) -> Vec<WolvesResultUser> {
  if config.wolves_url.is_empty() {
    return vec![];
  }

  // get wolves data
  if let Ok(mut res) = surf::post(&config.wolves_url).header("X-AM-Identity", wolves_api).await {
    if let Ok(WolvesResult {
      success,
      result,
    }) = res.body_json().await
    {
      if success != 1 {
        return vec![];
      }

      return result;
    }
  }

  vec![]
}

async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResultUser) {
  // expiry
  match sqlx::query_as::<_, Wolves>(
    "
      INSERT INTO wolves (id_wolves, email)
      VALUES ($1, $2)
      ON CONFLICT(id_wolves) DO UPDATE SET email = $2
    ",
  )
  .bind(&user.wolves_id)
  .bind(&user.contact_email)
  .fetch_optional(db)
  .await
  {
    Ok(_) => {}
    Err(e) => {
      println!("Failure to insert into Wolves {:?}", user);
      println!("{:?}", e);
    }
  }

  match sqlx::query_as::<_, ServerMembers>(
    "
      INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
      VALUES (?1, ?2, ?3)
    ",
  )
  .bind(*server.as_u64() as i64)
  .bind(&user.wolves_id)
  .bind(&user.expiry)
  .fetch_optional(db)
  .await
  {
    Ok(_) => {}
    Err(e) => {
      println!("Failure to insert into ServerMembers {}  {:?}", server.as_u64(), user);
      println!("{:?}", e);
    }
  }
}