use phoebe::prelude::*;
use serenity::{
    client::{Context, EventHandler},
    model::prelude::*,
    prelude::*,
    Client,
};
use tracing::{debug, info};

pub struct DiscordService {
    discord_client: Client,
    discord_ctx: Context,
}

struct DiscordHandler {
    core_db: SqlitePool,
    discord_media_db: SqlitePool,
    chat_event_tx: ChatEventSender,
    ctx_tx: tokio::sync::mpsc::Sender<Context>,
}

#[async_trait]
impl EventHandler for DiscordHandler {
    async fn ready(&self, ctx: Context, _data_about_bot: Ready) {
        let _ = self.ctx_tx.send(ctx).await;
    }
}

pub async fn setup(core_db: SqlitePool, tx: ChatEventSender) -> Result<DiscordService> {
    info!("Setting up Discord service…");

    let discord_media_db = phoebe::db::open("discord_media").await?;
    sqlx::migrate!().run(&discord_media_db).await?;

    let (ctx_tx, mut ctx_rx) = tokio::sync::mpsc::channel::<Context>(1);

    let discord_handler = DiscordHandler {
        core_db,
        discord_media_db,
        chat_event_tx: tx,
        ctx_tx,
    };

    // TODO: Create a discord client
    debug!("Logging in…");
    let discord_token = std::env::var("PHOEBE_DISCORD_TOKEN")
        .expect("PHOEBE_DISCORD_TOKEN environment variable was not set!");
    let client = Client::builder(&discord_token)
        .event_handler(discord_handler)
        .await?;

    let discord_ctx = ctx_rx.recv().await.expect("Couldn't get Discord context");
    debug!("Logged in!");

    Ok(DiscordService {
        discord_client: client,
        discord_ctx,
    })
}

#[async_trait]
impl Service for DiscordService {
    async fn handle_chat_event(&mut self, event: &ChatEvent) {
        dbg!(event);
    }

    fn get_service_tag(&self) -> &'static str {
        "discord"
    }
}