use phoebe::{
    mid_chat::{ChatMessage, ChatMessageReference, ChatReference},
    prelude::{future, Result},
};

use serenity::{model::prelude::*, prelude::*};

use crate::{chat_conv, discord_reference, DiscordService};

pub async fn send_discord_message(
    discord: &mut DiscordService,
    source: &ChatMessage,
    destination_channel: ChatReference,
) -> Result<ChatMessageReference> {
    // TODO: If we have a webhook we should use the webhook

    let channel_id = destination_channel.id.parse::<ChannelId>()?;
    let formatted_message = chat_conv::format(&source.content);
    let content = format!(
        "{} ({}): {}",
        source.author.display_name, source.author.reference.service, formatted_message
    );

    let discord_reply = if let Some(reply) = &source.replying {
        if let Some(reply_ref) = discord
            .lookup_message(reply, |r| future::ready(r.channel == destination_channel))
            .await
        {
            assert_eq!(reply_ref.channel.service, "discord");
            let channel_id: ChannelId = reply_ref.channel.id.parse().unwrap();
            let message_id: MessageId = reply_ref.message_id.parse::<u64>().unwrap().into();
            Some((channel_id, message_id))
        } else {
            None
        }
    } else {
        None
    };

    let sent_message = channel_id
        .send_message(&discord.ctx, move |m| {
            let m = m.content(content);
            if let Some(reply) = discord_reply {
                m.reference_message(reply)
            } else {
                m
            }
        })
        .await?;

    Ok(ChatMessageReference::new(
        discord_reference(sent_message.channel_id),
        sent_message.id,
    ))
}