macltok

use std::sync::Arc;

use matrix_sdk::{room::MessagesOptions, Room};

use matrix_sdk_ui::timeline::{RoomExt, TimelineEventFocusThreadMode, TimelineFocus};

use ruma::{uint, OwnedEventId};

use crate::{

    normalise::{normalise_timeline, MediaScope},

    Error, ErrorKind, EventContext, EventContextCommand, EventContextDirection, EventContextPage,

    TimelineItem,

};

const MAX_CONTEXT_LIMIT: u16 = 50;

pub(crate) async fn execute(

    room: Room,

    current_user_id: Option<ruma::OwnedUserId>,

    command: EventContextCommand,

) -> Result<crate::CommandOutput, Error> {

    if let EventContextCommand::Before { token, limit, .. }

    | EventContextCommand::After { token, limit, .. } = &command

    {

        validate_limit(*limit)?;

        if token.is_empty() {

            return Err(Error::new(

                ErrorKind::Invalid,

                "context pagination token is empty",

            ));

        }

        return execute_page(

            room,

            current_user_id,

            token,

            *limit,

            matches!(command, EventContextCommand::Before { .. }),

        )

        .await;

    }

    let (event_id, limit) = match &command {

        EventContextCommand::Fetch {

            event_id,

            before_limit,

            after_limit,

            ..

        } => {

            validate_limit(*before_limit)?;

            validate_limit(*after_limit)?;

            (event_id.clone(), (*before_limit).max(*after_limit))

        }

        EventContextCommand::Before { .. } | EventContextCommand::After { .. } => unreachable!(),

    };

    validate_limit(limit)?;

    let raw_context = if matches!(command, EventContextCommand::Fetch { .. }) {

        Some(

            room.event_with_context(&event_id, false, uint!(0), None)

                .await

                .map_err(|source| {

                    let error = Error::from_sdk("fetching event context failed", source);

                    if error

                        .server

                        .as_ref()

                        .is_some_and(|server| server.status == 404)

                    {

                        Error::new(ErrorKind::EventNotFound, "event was not found")

                    } else {

                        error

                    }

                })?,

        )

    } else {

        None

    };

    let focus = TimelineFocus::Event {

        target: event_id.clone(),

        num_context_events: limit,

        thread_mode: TimelineEventFocusThreadMode::Automatic {

            hide_threaded_events: true,

        },

    };

    let timeline = room

        .timeline_builder()

        .with_focus(focus)

        .build()

        .await

        .map_err(|source| {

            Error::with_source(ErrorKind::Timeline, "building event context failed", source)

        })?;

    if let EventContextCommand::Fetch { .. } = command {

        let raw = raw_context.expect("fetch context response");

        let normalized = normalize_items(timeline.items().await, current_user_id.as_deref());

        let (before, event, after) = split_items(normalized, &event_id);

        if event.is_none() && raw.event.is_none() {

            return Err(Error::new(ErrorKind::EventNotFound, "event was not found"));

        }

        return Ok(crate::CommandOutput::EventContext(EventContext {

            events_before: before,

            event,

            events_after: after,

            start_token: raw.prev_batch_token,

            end_token: raw.next_batch_token,

        }));

    }

    unreachable!("fetch context returned above")

}

async fn execute_page(

    room: Room,

    current_user_id: Option<ruma::OwnedUserId>,

    token: &str,

    limit: u16,

    backwards: bool,

) -> Result<crate::CommandOutput, Error> {

    let mut options = if backwards {

        MessagesOptions::backward()

    } else {

        MessagesOptions::forward()

    };

    options = options.from(token);

    options.limit = ruma::UInt::from(limit);

    let messages = room

        .messages(options)

        .await

        .map_err(|source| Error::from_sdk("fetching event context page failed", source))?;

    let ids: Vec<_> = messages

        .chunk

        .iter()

        .filter_map(|event| event.event_id())

        .collect();

    let normalized = if let Some(target) = ids.first() {

        let focus = TimelineFocus::Event {

            target: target.clone(),

            num_context_events: limit,

            thread_mode: TimelineEventFocusThreadMode::Automatic {

                hide_threaded_events: false,

            },

        };

        let timeline = room

            .timeline_builder()

            .with_focus(focus)

            .build()

            .await

            .map_err(|source| {

                Error::with_source(

                    ErrorKind::Timeline,

                    "building event context page failed",

                    source,

                )

            })?;

        normalize_items(timeline.items().await, current_user_id.as_deref())

    } else {

        Vec::new()

    };

    let mut by_id = std::collections::HashMap::new();

    for item in normalized {

        if let TimelineItem::Event(event) = &item {

            if let Some(event_id) = &event.event_id {

                by_id.insert(event_id.clone(), item);

            }

        }

    }

    let mut events: Vec<_> = ids.iter().filter_map(|id| by_id.remove(id)).collect();

    if backwards {

        events.reverse();

    }

    let next_token = messages.end.clone();

    let end_reached = next_token.is_none();

    let direction = if backwards {

        EventContextDirection::Before

    } else {

        EventContextDirection::After

    };

    Ok(crate::CommandOutput::EventContextPage(EventContextPage {

        direction,

        events,

        next_token,

        end_reached,

    }))

}

fn validate_limit(limit: u16) -> Result<(), Error> {

    if limit > MAX_CONTEXT_LIMIT {

        Err(Error::new(ErrorKind::Invalid, "context limit exceeds 50"))

    } else {

        Ok(())

    }

}

fn normalize_items(

    items: imbl::Vector<Arc<matrix_sdk_ui::timeline::TimelineItem>>,

    current_user_id: Option<&ruma::UserId>,

) -> Vec<TimelineItem> {

    let scope = MediaScope::new();

    normalise_timeline(items.iter(), current_user_id, &scope)

        .items

        .into_iter()

        .collect()

}

fn split_items(

    items: Vec<TimelineItem>,

    event_id: &OwnedEventId,

) -> (Vec<TimelineItem>, Option<TimelineItem>, Vec<TimelineItem>) {

    let items: Vec<_> = items

        .into_iter()

        .filter(|item| matches!(item, TimelineItem::Event(_)))

        .collect();

    let target = items.iter().position(|item| {

        matches!(item, TimelineItem::Event(event) if event.event_id.as_ref() == Some(event_id))

    });

    let Some(index) = target else {

        return (items, None, Vec::new());

    };

    let mut before = items;

    let after = before.split_off(index + 1);

    let event = before.pop();

    (before, event, after)

}