use log::{warn, info, error};
use serenity::all::Interaction;
use serenity::async_trait;
use serenity::model::gateway::Ready;
use serenity::model::channel::Message;
use serenity::prelude::*;

use crate::data::guilds::GuildCache;
use super::{commands, oai};
use super::commands::audio::create_response;

pub struct Handler {
  // Open AI Config
  pub oai: Option<oai::OAI>,
}

#[async_trait]
impl EventHandler for Handler {
  async fn message(&self, ctx: Context, msg: Message) {
    // Ignore messages from bots
    if msg.author.bot {
      return;
    }
    match &self.oai {
      Some(oai) => {
        match msg.mentions_me(&ctx.http).await {
          Ok(mentioned) => {
            let bot_in_thread = match msg.channel_id.get_thread_members(&ctx.http).await {
              Ok(t) => match t.iter().find(|t| t.user_id == ctx.cache.current_user().id) {
                Some(_) => true,
                None => false,
              },
              Err(_) => false,
            };
            if mentioned || bot_in_thread {
              commands::chat::generate_response(&ctx, &msg, oai).await;
            }
          }
          Err(why) => warn!("Could not check mentions: {:?}", why),
        };
      }
      None => {}
    }
  }

  async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
    if let Interaction::Command(command) = interaction {
      log::trace!("Received command interaction: {command:#?}");
      match command.data.name.as_str() {
        // Match commands without returns
        "play" => commands::audio::play::run(&ctx, &command).await,
        "stop" => commands::audio::stop::run(&ctx, &command).await,
        "pause" => commands::audio::pause::run(&ctx, &command).await,
        "resume" => commands::audio::resume::run(&ctx, &command).await,
        "mute" => commands::audio::mute::run(&ctx, &command).await,
        "skip" => commands::audio::skip::run(&ctx, &command).await,
        "volume" => commands::audio::volume::run(&ctx, &command).await,
        "schedule" => commands::event::schedule::run(&ctx, &command).await,
        "roll" => commands::fun::roll::run(&ctx, &command).await,
        _ => {
          let content: String = match command.data.name.as_str() {
            // Match commands with string returns
            "ping" => commands::utility::ping::run(&command.data.options),
            _ => "Unknown command".to_string(),
          };
          create_response(&ctx, &command, content).await;
        }
      }
    }
  }

  async fn ready(&self, ctx: Context, ready: Ready) {
    if ready.guilds.is_empty() {
      warn!("No ready guilds found");
    }
    for guild in ready.guilds {
      // Check if guild exists in database
      let guild_id = guild.id.get() as i64;
      if let None = GuildCache::get_by_id(guild_id).await.unwrap() {
        let guild_cache = GuildCache {
          id: guild_id,
          bot_id: 1,
          volume: 100,
        };
        guild_cache.insert().await.unwrap();
      }
      let commands = guild
        .id
        .set_commands(
          &ctx.http,
          vec![
            commands::audio::play::register(),
            commands::audio::stop::register(),
            commands::audio::pause::register(),
            commands::audio::resume::register(),
            commands::audio::mute::register(),
            commands::audio::skip::register(),
            commands::audio::volume::register(),
            commands::event::schedule::register(),
            commands::fun::roll::register(),
            commands::utility::ping::register(),
          ],
        )
        .await;
      match commands {
        Ok(c) => info!(
          "Registered {} commands for guild {}",
          c.len(),
          guild.id.get()
        ),
        Err(why) => error!(
          "Could not register commands for guild {}: {:?}",
          guild.id.get(),
          why
        ),
      };
    }
  }
}