mod commands;

use serenity::{
  async_trait,
  client::{Context, EventHandler},
  model::{
    gateway::{GatewayIntents, Ready},
    guild,
    application::{interaction::{Interaction, InteractionResponseType}, command::Command},
  },
  Client,
};
use std::sync::Arc;
use serenity::model::prelude::interaction;

use skynet_discord_bot::{db_init, get_config, get_server_config, get_server_member, Config, DataBase};
use tokio::sync::RwLock;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
  async fn guild_member_addition(&self, ctx: Context, mut new_member: guild::Member) {
    let db_lock = {
      let data_read = ctx.data.read().await;
      data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
    };

    let db = db_lock.read().await;
    let config = match get_server_config(&db, &new_member.guild_id).await {
      None => return,
      Some(x) => x,
    };

    if get_server_member(&db, &new_member.guild_id, &new_member).await.is_some() {
      let mut roles = vec![];

      if let Some(role) = &config.role_past {
        if !new_member.roles.contains(role) {
          roles.push(role.to_owned());
        }
      }

      if let Some(role) = &config.role_current {
        if !new_member.roles.contains(role) {
          roles.push(role.to_owned());
        }
      }

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

  async fn ready(&self, ctx: Context, ready: Ready) {
    println!("[Main] {} is connected!", ready.user.name);

    
    Command::set_global_application_commands(&ctx.http, |commands| {
      commands
        .create_application_command(|command| commands::link_email::register(command))
    })
      .await.ok();
    
  }

  async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
    if let Interaction::ApplicationCommand(command) = interaction {
      //println!("Received command interaction: {:#?}", command);

      let content = match command.data.name.as_str() {
        "link" => commands::link_email::run(&command, &ctx).await,
        _ => "not implemented :(".to_string(),
      };

      if let Err(why) = command
        .create_interaction_response(&ctx.http, |response| {
          response
            .kind(InteractionResponseType::ChannelMessageWithSource)
            .interaction_response_data(|message| message.content(content).ephemeral(true))
        })
        .await
      {
        println!("Cannot respond to slash command: {}", why);
      }
    }
  }
}

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

  // Intents are a bitflag, bitwise operations can be used to dictate which intents to use
  let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
  // Build our client.
  let mut client = Client::builder(&config.discord_token, intents)
    .event_handler(Handler {})
    .await
    .expect("Error creating client");

  {
    let mut data = client.data.write().await;

    data.insert::<Config>(Arc::new(RwLock::new(config)));
    data.insert::<DataBase>(Arc::new(RwLock::new(db)));
  }

  // Finally, start a single shard, and start listening to events.
  //
  // Shards will automatically attempt to reconnect, and will perform
  // exponential backoff until it reconnects.
  if let Err(why) = client.start().await {
    println!("Client error: {:?}", why);
  }
}