use serenity::{
  builder::CreateApplicationCommand,
  client::Context,
  model::{
    application::interaction::application_command::ApplicationCommandInteraction,
    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
  },
};

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

pub mod edit {
  use super::*;

  pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
    // check if user has high enough permisssions
    if let Some(msg) = is_admin(command, ctx).await {
      return msg;
    }

    let role_a = if let CommandDataOptionValue::Role(role) = command
      .data
      .options
      .get(0)
      .expect("Expected role option")
      .resolved
      .as_ref()
      .expect("Expected role object")
    {
      role.id.to_owned()
    } else {
      return "Please provide a valid role for ``Role Current``".to_string();
    };

    let role_b = if let CommandDataOptionValue::Role(role) = command
      .data
      .options
      .get(1)
      .expect("Expected role option")
      .resolved
      .as_ref()
      .expect("Expected role object")
    {
      role.id.to_owned()
    } else {
      return "Please provide a valid role for ``Role Current``".to_string();
    };

    let role_c = if let CommandDataOptionValue::Role(role) = command
      .data
      .options
      .get(2)
      .expect("Expected role option")
      .resolved
      .as_ref()
      .expect("Expected role object")
    {
      role.id.to_owned()
    } else {
      return "Please provide a valid role for ``Role Current``".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 mut delete = false;

    if let Some(x) = command.data.options.get(3) {
      let tmp = x.to_owned();
      if let Some(y) = tmp.resolved {
        match y {
          CommandDataOptionValue::Boolean(z) => {
            delete = z;
          }
          _ => {}
        }
      }
    }

    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)
    }
  }

  pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
    command
      .name("roles_adder")
      .description("Combine roles together to an new one")
      .create_option(|option| {
        option
          .name("role_a")
          .description("A role you want to add to Role B")
          .kind(CommandOptionType::Role)
          .required(true)
      })
      .create_option(|option| {
        option
          .name("role_b")
          .description("A role you want to add to Role A")
          .kind(CommandOptionType::Role)
          .required(true)
      })
      .create_option(|option| option.name("role_c").description("Sum of A and B").kind(CommandOptionType::Role).required(true))
      .create_option(|option| {
        option
          .name("delete")
          .description("Delete this entry.")
          .kind(CommandOptionType::Boolean)
          .required(false)
      })
  }

  async fn add_server(db: &Pool<Sqlite>, server: &RoleAdder, delete: bool) -> Result<Option<RoleAdder>, Error> {
    let action;
    if delete {
      action = 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.as_u64() as i64)
      .bind(*server.role_a.as_u64() as i64)
      .bind(*server.role_b.as_u64() as i64)
      .bind(*server.role_c.as_u64() as i64)
      .fetch_optional(db)
      .await;
    } else {
      action = 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.as_u64() as i64)
      .bind(*server.role_a.as_u64() as i64)
      .bind(*server.role_b.as_u64() as i64)
      .bind(*server.role_c.as_u64() as i64)
      .fetch_optional(db)
      .await;
    }

    action
  }
}

// TODO
pub mod list {}

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

  pub async fn on_role_change(db: &Pool<Sqlite>, ctx: &Context, mut 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.as_u64() 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);
        }
      }
    }
  }
}