use serenity::client::Context;

use skynet_discord_bot::common::database::{DataBase, RoleAdder};
use sqlx::{Error, Pool, Sqlite};

pub mod edit {
  use super::*;
  use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction};

  pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
    let sub_options = if let Some(CommandDataOption {
      value: CommandDataOptionValue::SubCommand(options),
      ..
    }) = command.data.options.first()
    {
      options
    } else {
      return "Please provide sub options".to_string();
    };

    let role_a = if let Some(x) = sub_options.first() {
      match &x.value {
        CommandDataOptionValue::Role(role) => role.to_owned(),
        _ => return "Please provide a valid role for ``Role A``".to_string(),
      }
    } else {
      return "Please provide a valid role for ``Role A``".to_string();
    };

    let role_b = if let Some(x) = sub_options.get(1) {
      match &x.value {
        CommandDataOptionValue::Role(role) => role.to_owned(),
        _ => return "Please provide a valid role for ``Role B``".to_string(),
      }
    } else {
      return "Please provide a valid role for ``Role B``".to_string();
    };

    let role_c = if let Some(x) = sub_options.get(2) {
      match &x.value {
        CommandDataOptionValue::Role(role) => role.to_owned(),
        _ => return "Please provide a valid role for ``Role C``".to_string(),
      }
    } else {
      return "Please provide a valid role for ``Role C``".to_string();
    };

    if role_a == role_b {
      return "Roles A and B must be different".to_string();
    }

    if (role_c == role_a) || (role_c == role_b) {
      return "Role C cannot be same as A or B".to_string();
    }

    let delete = if let Some(x) = sub_options.get(3) {
      match &x.value {
        CommandDataOptionValue::Boolean(z) => *z,
        _ => false,
      }
    } else {
      false
    };

    let db_lock = {
      let data_read = ctx.data.read().await;
      data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
    };
    let db = db_lock.read().await;

    let server = command.guild_id.unwrap_or_default();
    let server_data = RoleAdder {
      server,
      role_a,
      role_b,
      role_c,
    };

    match add_server(&db, &server_data, delete).await {
      Ok(_) => {}
      Err(e) => {
        println!("{:?}", e);
        return format!("Failure to insert into Servers {:?}", server_data);
      }
    }

    let mut role_a_name = String::new();
    let mut role_b_name = String::new();
    let mut role_c_name = String::new();

    if let Ok(x) = server.roles(&ctx).await {
      if let Some(y) = x.get(&role_a) {
        role_a_name = y.to_owned().name;
      }
      if let Some(y) = x.get(&role_b) {
        role_b_name = y.to_owned().name;
      }
      if let Some(y) = x.get(&role_b) {
        role_c_name = y.to_owned().name;
      }
    }

    if delete {
      format!("Removed {} + {} = {}", role_a_name, role_b_name, role_c_name)
    } else {
      format!("Added {} + {} = {}", role_a_name, role_b_name, role_c_name)
    }
  }

  async fn add_server(db: &Pool<Sqlite>, server: &RoleAdder, delete: bool) -> Result<Option<RoleAdder>, Error> {
    if delete {
      sqlx::query_as::<_, RoleAdder>(
        "
      DELETE FROM roles_adder
      WHERE server = ?1 AND role_a = ?2 AND role_b = ?3 AND role_c = ?4
    ",
      )
      .bind(server.server.get() as i64)
      .bind(server.role_a.get() as i64)
      .bind(server.role_b.get() as i64)
      .bind(server.role_c.get() as i64)
      .fetch_optional(db)
      .await
    } else {
      sqlx::query_as::<_, RoleAdder>(
        "
      INSERT OR REPLACE INTO roles_adder (server, role_a, role_b, role_c)
      VALUES (?1, ?2, ?3, ?4)
    ",
      )
      .bind(server.server.get() as i64)
      .bind(server.role_a.get() as i64)
      .bind(server.role_b.get() as i64)
      .bind(server.role_c.get() as i64)
      .fetch_optional(db)
      .await
    }
  }
}

// TODO
pub mod list {}

pub mod tools {
  use serenity::client::Context;
  use serenity::model::guild::Member;
  use skynet_discord_bot::common::database::RoleAdder;
  use sqlx::{Pool, Sqlite};

  pub async fn on_role_change(db: &Pool<Sqlite>, ctx: &Context, new_data: Member) {
    // check if the role changed is part of the oens for this server
    if let Ok(role_adders) = sqlx::query_as::<_, RoleAdder>(
      r#"
      SELECT *
      FROM roles_adder
      WHERE server = ?
      "#,
    )
    .bind(new_data.guild_id.get() as i64)
    .fetch_all(db)
    .await
    {
      let mut roles_add = vec![];
      let mut roles_remove = vec![];

      for role_adder in role_adders {
        // if the user has both A dnd B give them C
        if new_data.roles.contains(&role_adder.role_a) && new_data.roles.contains(&role_adder.role_b) && !new_data.roles.contains(&role_adder.role_c)
        {
          roles_add.push(role_adder.role_c);
        }

        // If the suer has C but not A or B remove C
        if new_data.roles.contains(&role_adder.role_c)
          && (!new_data.roles.contains(&role_adder.role_a) || !new_data.roles.contains(&role_adder.role_b))
        {
          roles_remove.push(role_adder.role_c);
        }
      }

      if !roles_add.is_empty() {
        if let Err(e) = new_data.add_roles(&ctx, &roles_add).await {
          println!("{:?}", e);
        }
      }

      if !roles_remove.is_empty() {
        if let Err(e) = new_data.remove_roles(&ctx, &roles_remove).await {
          println!("{:?}", e);
        }
      }
    }
  }
}