use std::{
    borrow::Cow,
    collections::{HashMap, HashSet},
};

use crossbeam_channel::Receiver;
use eframe::egui::{self, Color32, Label, ScrollArea, Sense};
use matrix_sdk::{
    deserialized_responses::SyncResponse,
    room::Room,
    ruma::{
        events::{room::message::MessageType, AnyMessageEvent, AnyRoomEvent},
        RoomId, UserId,
    },
    Client, RoomMember,
};
use serde::{Deserialize, Serialize};
use tokio::sync::mpsc::UnboundedSender;

use crate::sync;

use super::Id;

/// Logged in application state
#[derive(Debug)]
pub struct App {
    pub client: matrix_sdk::Client,
    pub request: UnboundedSender<sync::Request>,
    pub response: Receiver<sync::Response>,
    pub sync_handle: Option<std::thread::JoinHandle<()>>,
    pub error: Option<String>,

    pub room_list: RoomList,
    pub timelines: HashMap<RoomId, Timeline>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RoomList {
    pub selected_room: Option<matrix_sdk::ruma::identifiers::RoomId>,
    pub room_name: HashMap<RoomId, String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Timeline {
    messages: Vec<AnyRoomEvent>,
    #[serde(skip)]
    member: HashMap<UserId, RoomMember>,
    #[serde(skip)]
    member_pending: HashSet<UserId>,
}

impl RoomList {
    fn room_name<'a>(&'a self, room: &matrix_sdk::BaseRoom) -> Cow<'a, str> {
        if let Some(name) = self.room_name.get(room.room_id()) {
            name.into()
        } else if let Some(name) = room.name() {
            name.into()
        } else if let Some(alias) = room.canonical_alias() {
            String::from(alias).into()
        } else {
            room.room_id().to_string().into()
        }
    }

    fn is_selected(&self, room_id: &RoomId) -> bool {
        self.selected_room
            .as_ref()
            .map_or(false, |id| id == room_id)
    }

    fn selected_room(&self, client: &Client) -> Option<matrix_sdk::room::Room> {
        match self.selected_room {
            Some(ref selected) => client.get_room(selected),
            None => None,
        }
    }
}

impl App {
    pub fn new(
        client: Client,
        request: UnboundedSender<sync::Request>,
        response: Receiver<sync::Response>,
        sync_handle: std::thread::JoinHandle<()>,
    ) -> Self {
        Self {
            client,
            request,
            response,

            sync_handle: Some(sync_handle),
            room_list: RoomList::default(),
            error: None,
            timelines: HashMap::new(),
        }
    }

    pub fn update(&mut self, ctx: &egui::CtxRef) {
        if let Ok(response) = self.response.try_recv() {
            self.handle_response(response);
        }

        egui::SidePanel::left(Id::RoomPanel)
            .max_width(800.0)
            .default_width(400.0)
            .show(ctx, |ui| {
                ui.add(egui::Label::new("Joined").strong());
                for room in self.client.joined_rooms() {
                    let group = if self.room_list.is_selected(room.room_id()) {
                        egui::Frame::group(&Default::default())
                    } else {
                        egui::Frame::group(&Default::default()).fill(Color32::from_rgb(0, 0, 0))
                    };
                    let response = group.show(ui, |ui| {
                        ui.set_width(ui.available_width());
                        let name = self.room_list.room_name(&*room);
                        ui.label(&*name);
                    });
                    let response = response.response.interact(Sense::click());
                    if response.clicked() {
                        self.room_list.selected_room = Some(room.room_id().clone());
                    }
                }
            });

        let room = match self.room_list.selected_room(&self.client) {
            Some(room) => room,
            _ => return,
        };
        egui::TopBottomPanel::top(Id::RoomSummary).show(ctx, |ui| {
            ui.horizontal(|ui| {
                ui.set_width(ui.available_width());
                ui.heading(&*self.room_list.room_name(&room));
                if let Some(ref target) = room.direct_target() {
                    ui.label(target.as_str());
                } else if let Some(ref alias) = room.canonical_alias() {
                    ui.label(alias.as_str());
                }
                if let Some(ref topic) = room.topic() {
                    ui.label(topic);
                }
            })
        });

        egui::SidePanel::right(Id::MemberList).show(ctx, |ui| {
            ui.heading("Members");
            let timeline = self.timelines.entry(room.room_id().clone()).or_default();
            for member in timeline.member.values() {
                ui.label(member.name());
            }
        });

        let joined = match room {
            Room::Joined(ref room) => room,
            _ => return,
        };

        egui::CentralPanel::default().show(ctx, |ui| {
            ScrollArea::auto_sized().show(ui, |ui| {
                let timeline = self.timelines.entry(room.room_id().clone()).or_default();
                for event in timeline.messages.iter() {
                    let sender = event.sender();
                    let name = match timeline.member.get(sender) {
                        Some(member) => member.name(),
                        None => {
                            if !timeline.member_pending.contains(sender) {
                                self.request
                                    .send(sync::Request::JoinedMember(
                                        joined.clone(),
                                        sender.clone(),
                                    ))
                                    .ok();
                            }
                            sender.localpart()
                        }
                    };
                    match event {
                        AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(msg)) => {
                            match &msg.content.msgtype {
                                MessageType::Text(text) => {
                                    ui.add(Label::new(name).strong())
                                        .on_hover_text(event.sender());
                                    ui.label(&text.body);
                                }
                                MessageType::Notice(notice) => {
                                    ui.add(Label::new(name).strong())
                                        .on_hover_text(event.sender());
                                    ui.add(egui::Label::new(&notice.body).weak());
                                }
                                MessageType::ServerNotice(notice) => {
                                    ui.add(Label::new(name).strong())
                                        .on_hover_text(event.sender());
                                    ui.add(egui::Label::new(&notice.body).weak());
                                }
                                MessageType::Emote(emote) => {
                                    ui.label(format!("* {} {}", name, emote.body));
                                }
                                _ => (),
                            }
                        }
                        _ => (),
                    }
                }
            })
        });
    }

    fn handle_response(&mut self, response: sync::Response) {
        match response {
            sync::Response::RoomName(room, name) => {
                self.room_list.room_name.insert(room, name);
            }
            sync::Response::JoinedMember(room, member) => {
                self.timelines
                    .entry(room)
                    .or_default()
                    .member
                    .insert(member.user_id().clone(), member);
            }
            sync::Response::Error(e) => {
                self.error = Some(e.to_string());
            }
            sync::Response::Sync(sync) => self.handle_sync(sync),
        };
    }

    fn handle_sync(&mut self, sync: SyncResponse) {
        for (id, room) in sync.rooms.join {
            let timeline = self.timelines.entry(id.clone()).or_default();
            for event in room.timeline.events {
                let event = match event.event.deserialize() {
                    Ok(event) => event,
                    Err(_) => continue,
                };
                timeline.messages.push(event.into_full_event(id.clone()));
            }
        }
    }
}