macltok

use std::sync::Arc;

use matrix_sdk::{

    Room, deserialized_responses::TimelineEvent as SdkTimelineEvent, room::MessagesOptions,

};

use ruma::{OwnedEventId, OwnedUserId, RoomId, UInt};

use crate::{

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

    TimelineItem,

    engine::MediaService,

    normalise::{MediaRegistration, normalise_observed},

};

const MAX_CONTEXT_LIMIT: u16 = 50;

pub(crate) async fn execute(

    room: Room,

    current_user_id: Option<OwnedUserId>,

    media: Arc<MediaService>,

    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,

            media,

            token,

            *limit,

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

        )

        .await;

    }

    let (event_id, before_limit, after_limit) = match &command {

        EventContextCommand::Fetch {

            event_id,

            before_limit,

            after_limit,

            ..

        } => {

            validate_limit(*before_limit)?;

            validate_limit(*after_limit)?;

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

        }

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

    };

    let (context, registrations, _) =

        capture(room, current_user_id, event_id, before_limit, after_limit).await?;

    media.register(registrations).await;

    Ok(crate::CommandOutput::EventContext(context))

}

pub(crate) async fn capture(

    room: Room,

    current_user_id: Option<OwnedUserId>,

    event_id: OwnedEventId,

    before_limit: u16,

    after_limit: u16,

) -> Result<(EventContext, Vec<MediaRegistration>, Vec<serde_json::Value>), Error> {

    validate_limit(before_limit)?;

    validate_limit(after_limit)?;

    let raw = room

        .event_with_context(&event_id, false, UInt::from(0_u16), 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

            }

        })?;

    if raw.event.is_none() {

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

    }

    let before = fetch_side(

        &room,

        raw.prev_batch_token.as_deref(),

        before_limit,

        true,

        current_user_id.as_deref(),

    );

    let after = fetch_side(

        &room,

        raw.next_batch_token.as_deref(),

        after_limit,

        false,

        current_user_id.as_deref(),

    );

    let (events_before, mut before_media, start_token, mut observed) = before.await?;

    let (events_after, after_media, end_token, following) = after.await?;

    observed.extend(following);

    if let Some(value) = raw

        .event

        .as_ref()

        .and_then(|event| serde_json::from_str(event.raw().json().get()).ok())

    {

        observed.push(value);

    }

    let event = raw.event.as_ref().and_then(|event| {

        normalise_sdk_event(event, current_user_id.as_deref(), room.room_id()).map(

            |(item, media)| {

                before_media.extend(media);

                item

            },

        )

    });

    before_media.extend(after_media);

    Ok((

        EventContext {

            events_before,

            event,

            events_after,

            start_token,

            end_token,

        },

        before_media,

        observed,

    ))

}

async fn fetch_side(

    room: &Room,

    token: Option<&str>,

    limit: u16,

    backwards: bool,

    current_user_id: Option<&ruma::UserId>,

) -> Result<

    (

        Vec<TimelineItem>,

        Vec<MediaRegistration>,

        Option<String>,

        Vec<serde_json::Value>,

    ),

    Error,

> {

    if limit == 0 {

        return Ok((Vec::new(), Vec::new(), token.map(str::to_owned), Vec::new()));

    }

    let Some(token) = token else {

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

    };

    let mut options = if backwards {

        MessagesOptions::backward()

    } else {

        MessagesOptions::forward()

    };

    options = options.from(token);

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

    let messages = room

        .messages(options)

        .await

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

    let mut events = messages.chunk;

    events.truncate(usize::from(limit));

    if backwards {

        events.reverse();

    }

    let next_token = messages.end;

    let observed = events

        .iter()

        .filter_map(|event| serde_json::from_str(event.raw().json().get()).ok())

        .collect();

    let (items, media) = normalise_events(events, current_user_id, room.room_id());

    Ok((items, media, next_token, observed))

}

async fn execute_page(

    room: Room,

    current_user_id: Option<OwnedUserId>,

    media: Arc<MediaService>,

    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 = UInt::from(limit);

    let messages = room

        .messages(options)

        .await

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

    let next_token = messages.end.clone();

    let mut events = messages.chunk;

    events.truncate(usize::from(limit));

    if backwards {

        events.reverse();

    }

    let (events, registrations) =

        normalise_events(events, current_user_id.as_deref(), room.room_id());

    media.register(registrations).await;

    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 normalise_events(

    events: Vec<SdkTimelineEvent>,

    current_user_id: Option<&ruma::UserId>,

    room_id: &RoomId,

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

    let mut items = Vec::with_capacity(events.len());

    let mut media = Vec::new();

    for event in events {

        if let Some((item, registrations)) = normalise_sdk_event(&event, current_user_id, room_id) {

            items.push(item);

            media.extend(registrations);

        }

    }

    (items, media)

}

fn normalise_sdk_event(

    event: &SdkTimelineEvent,

    current_user_id: Option<&ruma::UserId>,

    room_id: &RoomId,

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

    let value: serde_json::Value = serde_json::from_str(event.raw().json().get()).ok()?;

    let event_id = value.get("event_id")?.as_str()?;

    let identity = format!("{room_id}\n{event_id}");

    normalise_observed(&value, current_user_id, &identity)

}

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

    if limit > MAX_CONTEXT_LIMIT {

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

    } else {

        Ok(())

    }

}