use matrix_sdk::{
    async_trait,
    room::Room,
    ruma::{
        api::client::r0::room::get_room_event,
        events::{
            room::message::{MessageEventContent, MessageFormat, MessageType},
            AnyMessageEvent, AnyRoomEvent, SyncMessageEvent,
        },
    },
    EventHandler,
};

use crate::MessageReference;

impl From<(&Room, &SyncMessageEvent<MessageEventContent>)> for MessageReference {
    fn from((room, event): (&Room, &SyncMessageEvent<MessageEventContent>)) -> Self {
        let room_string = room.room_id().as_str().to_string();
        let event_string = event.event_id.as_str().to_string();

        Self::Matrix(room_string, event_string)
    }
}

struct MatrixHandler;

#[async_trait]
impl EventHandler for MatrixHandler {
    async fn on_room_message(&self, room: Room, event: &SyncMessageEvent<MessageEventContent>) {
        let event_id = &event.event_id;

        if let Room::Joined(room) = room {
            let event = room
                .event(get_room_event::Request::new(room.room_id(), event_id))
                .await
                .unwrap()
                .event
                .deserialize()
                .unwrap();

            if let AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(message)) = event {
                if let MessageEventContent {
                    msgtype: MessageType::Text(text_content),
                    ..
                } = &message.content
                {
                    if let Some(html_body) = text_content
                        .formatted
                        .as_ref()
                        .filter(|f| f.format == MessageFormat::Html)
                        .map(|f| &f.body)
                    {
                        // TODO: Parse the html_body into the AST
                    }
                }
            }
        }
    }
}