macltok

use std::collections::{BTreeMap, HashMap};

use matrix_sdk::{

    Room, RoomState, deserialized_responses::TimelineEvent, serde_helpers::extract_thread_root,

};

use ruma::{

    OwnedEventId, UserId,

    events::receipt::{ReceiptThread, ReceiptType},

};

use serde_json::Value;

use crate::ThreadUnread;

struct Reply {

    event_id: Option<OwnedEventId>,

    own: bool,

    counts: bool,

    notify: bool,

    highlight: bool,

}

impl Reply {

    fn of(event: &TimelineEvent, own_user_id: &UserId) -> Self {

        let own = event.sender().as_deref() == Some(own_user_id);

        let counts = !own && counts_as_unread(event);

        let actions = event.push_actions().unwrap_or_default();

        Self {

            event_id: event.event_id(),

            own,

            counts,

            notify: counts && actions.iter().any(|action| action.should_notify()),

            highlight: counts && actions.iter().any(|action| action.is_highlight()),

        }

    }

}

/// the sdk leaves thread events out of the room's counts once threads are on and keeps none

/// of its own for them. so these are worked out the same way over the events it has in

/// memory, newest first until a receipt for that thread (msc3771), an unthreaded receipt or

/// the user's own reply. a receipt older than memory counts everything in memory, as the

/// sdk's does

pub(crate) async fn thread_unreads(room: &Room) -> BTreeMap<OwnedEventId, ThreadUnread> {

    if room.state() != RoomState::Joined {

        return BTreeMap::new();

    }

    let own_user_id = room.own_user_id();

    let unthreaded = own_receipts(room, ReceiptThread::Unthreaded).await;

    let Ok((cache, _drop_handles)) = room.event_cache().await else {

        return BTreeMap::new();

    };

    let mut threads: HashMap<OwnedEventId, Vec<Reply>> = HashMap::new();

    let scanned = cache

        .rfind_map_event_in_memory_by(|event| {

            let event_id = event.event_id();

            if event_id.is_some_and(|event_id| unthreaded.contains(&event_id)) {

                return Some(());

            }

            if let Some(root) = extract_thread_root(event.raw()) {

                threads

                    .entry(root)

                    .or_default()

                    .push(Reply::of(event, own_user_id));

            }

            None

        })

        .await;

    if let Err(error) = scanned {

        tracing::debug!(room_id = %room.room_id(), %error, "reading events for thread unreads failed");

        return BTreeMap::new();

    }

    let mut unreads = BTreeMap::new();

    for (root, replies) in threads {

        let read = own_receipts(room, ReceiptThread::Thread(root.clone())).await;

        let mut unread = ThreadUnread::default();

        for reply in replies {

            if reply.own

                || reply

                    .event_id

                    .as_ref()

                    .is_some_and(|event_id| read.contains(event_id))

            {

                break;

            }

            unread.messages += u64::from(reply.counts);

            unread.notifications += u64::from(reply.notify);

            unread.mentions += u64::from(reply.highlight);

        }

        if unread != ThreadUnread::default() {

            unreads.insert(root, unread);

        }

    }

    unreads

}

async fn own_receipts(room: &Room, thread: ReceiptThread) -> Vec<OwnedEventId> {

    let mut found = Vec::new();

    for receipt_type in [ReceiptType::Read, ReceiptType::ReadPrivate] {

        match room

            .load_user_receipt(receipt_type, thread.clone(), room.own_user_id())

            .await

        {

            Ok(Some((event_id, _))) => found.push(event_id),

            Ok(None) => {}

            Err(error) => {

                tracing::debug!(room_id = %room.room_id(), %error, "reading a receipt failed");

            }

        }

    }

    found

}

/// the sdk's rule for its room counts, which is private to it

fn counts_as_unread(event: &TimelineEvent) -> bool {

    let raw = event.raw();

    let redacted = raw

        .get_field::<Value>("unsigned")

        .ok()

        .flatten()

        .is_some_and(|unsigned| unsigned.get("redacted_because").is_some());

    let message_like = matches!(

        raw.get_field::<String>("type").ok().flatten().as_deref(),

        Some(

            "m.room.message"

                | "m.room.encrypted"

                | "m.sticker"

                | "m.poll.start"

                | "org.matrix.msc3381.poll.start"

                | "m.poll.end"

                | "org.matrix.msc3381.poll.end"

        )

    );

    message_like && !redacted

}