use serenity::{async_trait, model::prelude::*, prelude::*};
use tokio::sync::mpsc;
use tracing::info;

use crate::{message_ast, MessageReference, SentMessage};

pub use serenity::client::Context;

impl From<&Message> for MessageReference {
    fn from(message: &Message) -> Self {
        Self::Discord(message.channel_id.0, message.id.0)
    }
}

// TODO: Some way to emit messages for matrix,
// and some way to receive messages from matrix.
struct DiscordHandler {
    ctx_tx: mpsc::UnboundedSender<Context>,
    message_tx: mpsc::UnboundedSender<SentMessage>,
}

#[async_trait]
impl EventHandler for DiscordHandler {
    async fn ready(&self, ctx: Context, _ready: Ready) {
        info!("Discord side: Ready");

        let _ = self.ctx_tx.send(ctx);
        // TODO: Scan for channels to link
    }

    async fn message(&self, _ctx: Context, message: Message) {
        let message_ref = MessageReference::from(&message);
        // TODO: Store this message ref & associations in the DB

        let content = discord_message_format::parse(&message.content);
        let content = message_ast::convert_discord(&content);

        let _ = self.message_tx.send(SentMessage {
            source: message_ref,
            content,
        });
    }
}

pub async fn create_discord_client(
    ctx_tx: mpsc::UnboundedSender<Context>,
    message_tx: mpsc::UnboundedSender<SentMessage>,
    token: &str,
) -> Client {
    let handler = DiscordHandler { ctx_tx, message_tx };

    Client::builder(token)
        .event_handler(handler)
        .await
        .expect("Failed to create discord client")
}