use std::{str::FromStr, sync::Arc};

use matrix_sdk::{
    room::{Joined, Room},
    ruma::{
        events::{
            room::{
                message::{
                    FormattedBody, MessageEventContent, MessageFormat, MessageType, Relation,
                },
                redaction::RedactionEventContent,
            },
            AnyMessageEvent, AnyMessageEventContent, AnyRoomEvent, AnySyncRoomEvent,
            SyncMessageEvent,
        },
        EventId, UserId,
    },
    ClientConfig, SyncSettings,
};
pub use matrix_sdk::{ruma::RoomId, Client};

use log::info;
use tokio::sync::mpsc;
use url::Url;

use crate::{
    message_ast::{
        convert_matrix, convert_plain, format_discord, format_matrix, MessageComponent,
        MessageContent,
    },
    messages::{MessageAuthor, MessageEvent, MessageReference, SentMessage},
};

impl From<(&RoomId, &EventId)> for MessageReference {
    fn from((room_id, event_id): (&RoomId, &EventId)) -> Self {
        let room_string = room_id.as_str().to_string();
        let event_string = event_id.as_str().to_string();

        Self::Matrix(room_string, event_string)
    }
}

fn _find_content(event: &AnySyncRoomEvent) -> Option<AnyMessageEventContent> {
    match event {
        AnySyncRoomEvent::Message(message) => Some(message.content()),
        AnySyncRoomEvent::RedactedMessage(message) => {
            if let Some(ref redaction_event) = message.unsigned().redacted_because {
                Some(AnyMessageEventContent::RoomRedaction(
                    redaction_event.content.clone(),
                ))
            } else {
                Some(AnyMessageEventContent::RoomRedaction(
                    RedactionEventContent::new(),
                ))
            }
        }
        AnySyncRoomEvent::RedactedState(state) => {
            if let Some(ref redaction_event) = state.unsigned().redacted_because {
                Some(AnyMessageEventContent::RoomRedaction(
                    redaction_event.content.clone(),
                ))
            } else {
                Some(AnyMessageEventContent::RoomRedaction(
                    RedactionEventContent::new(),
                ))
            }
        }

        _ => None,
    }
}

struct MatrixHandler {
    message_tx: mpsc::UnboundedSender<MessageEvent>,
    current_user_id: UserId,
}

impl MatrixHandler {
    async fn get_message_author(&self, room: &Joined, user_id: &UserId) -> Option<MessageAuthor> {
        if let Ok(Some(sender)) = room.get_member(user_id).await {
            Some(MessageAuthor {
                display_name: sender
                    .display_name()
                    .unwrap_or_else(|| sender.name())
                    .to_string(),
            })
        } else {
            None
        }
    }

    fn get_content(&self, body: &str, formatted_body: &Option<FormattedBody>) -> MessageContent {
        if let Some(html) = formatted_body
            .as_ref()
            .filter(|f| f.format == MessageFormat::Html)
            .map(|f| &f.body)
        {
            convert_matrix(html)
        } else {
            convert_plain(body)
        }
    }
}

async fn on_room_message_event(
    ctx: Arc<MatrixHandler>,
    event: SyncMessageEvent<MessageEventContent>,
    room: Room,
) {
    if event.sender == ctx.current_user_id {
        return;
    }

    if let Room::Joined(room) = room {
        let message_ref = MessageReference::from((room.room_id(), &event.event_id));

        let message_type =
            if let Some(Relation::Replacement(replacement)) = &event.content.relates_to {
                &replacement.new_content.msgtype
            } else {
                &event.content.msgtype
            };

        match message_type {
            MessageType::Text(text) => {
                let content = ctx.get_content(&text.body, &text.formatted);

                if let Some(author) = ctx.get_message_author(&room, &event.sender).await {
                    let replies_to =
                        if let Some(Relation::Reply { in_reply_to }) = &event.content.relates_to {
                            Some(MessageReference::from((
                                room.room_id(),
                                &in_reply_to.event_id,
                            )))
                        } else {
                            None
                        };

                    let _ = ctx.message_tx.send(MessageEvent::Send(SentMessage {
                        source: message_ref,
                        content,
                        author,
                        replies_to,
                    }));
                }
            }

            MessageType::Emote(emote) => {
                let mut content = ctx.get_content(&emote.body, &emote.formatted);
                content.insert(0, MessageComponent::Plain("* ".to_string()));

                if let Some(author) = ctx.get_message_author(&room, &event.sender).await {
                    let _ = ctx.message_tx.send(MessageEvent::Send(SentMessage {
                        source: message_ref,
                        content,
                        author,
                        replies_to: None,
                    }));
                }
            }

            // TODO: Handle reactions, uploads (audio, video, image, file), and any other types of event
            _ => {}
        };

        let _ = room.read_receipt(&event.event_id).await;
    }
}

pub async fn forward_to_matrix(
    client: &Client,
    room_id: RoomId,
    message: &SentMessage,
    reply: Option<(String, String)>,
) -> Option<MessageReference> {
    if let Some(room) = client.get_joined_room(&room_id) {
        let replied_message_event = if let Some((room_id, event_id)) = reply {
            let event = room
                .event(
                    matrix_sdk::ruma::api::client::r0::room::get_room_event::Request::new(
                        &RoomId::from_str(&room_id).unwrap(),
                        &EventId::from_str(&event_id).unwrap(),
                    ),
                )
                .await
                .unwrap()
                .event
                .deserialize()
                .unwrap();

            if let AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(original_message_event)) =
                event
            {
                Some(original_message_event)
            } else {
                None
            }
        } else {
            None
        };

        let content = if let Some(replied_message_event) = &replied_message_event {
            MessageEventContent::text_reply_html(
                format_discord(&message.content),
                format_matrix(&message.content),
                replied_message_event,
            )
        } else {
            MessageEventContent::text_html(
                format_discord(&message.content),
                format_matrix(&message.content),
            )
        };

        let event = room
            .send(AnyMessageEventContent::RoomMessage(content), None)
            .await
            .ok()?;

        return Some(MessageReference::from((&room_id, &event.event_id)));
    }

    None
}

pub async fn create_matrix_client(
    homeserver_url: String,
    username: String,
    password: String,
    message_tx: mpsc::UnboundedSender<MessageEvent>,
) -> Client {
    let client_config = ClientConfig::new().store_path("./data/matrix_state");

    let homeserver_url =
        Url::parse(&homeserver_url).expect("Failed to parse the matrix homeserver URL");
    let client = Client::new_with_config(homeserver_url, client_config).unwrap();

    info!("Matrix logging in…");
    client
        .login(&username, &password, None, Some("phoebe"))
        .await
        .expect("Failed to log in");

    info!("Matrix starting…");
    client.sync_once(SyncSettings::default()).await.unwrap();

    let current_user_id = client.user_id().await.unwrap();

    let event_handler = Arc::new(MatrixHandler {
        message_tx,
        current_user_id,
    });

    client
        .register_event_handler(move |ev, room| {
            on_room_message_event(Arc::clone(&event_handler), ev, room)
        })
        .await;

    client
}