malice

import type { TimelineItem } from './types';

export const FEDERATION_LAG_MS = 60 * 1000;

const decorated = new WeakMap<TimelineItem, { lag: number; item: TimelineItem }>();

function withLag(item: TimelineItem & { kind: 'event' }, lag: number): TimelineItem {

  const hit = decorated.get(item);

  if (hit && hit.lag === lag) return hit.item;

  const next: TimelineItem = { ...item, event: { ...item.event, delivery_lag_ms: lag } };

  decorated.set(item, { lag, item: next });

  return next;

}

/**

 * Carries delivery lag forward from the previous list and measures it for events appended

 * after the last one already known. `since` is when the room last became able to receive

 * events, so catch-up after being offline or closed doesn't count as federation delay.

 * Returns null when nothing in `items` was known before, meaning the list was replaced.

 */

export function observeArrivals(previous: TimelineItem[], items: TimelineItem[], since: number, now: number): TimelineItem[] | null {

  const lags = new Map<string, number | undefined>();

  for (const item of previous) if (item.kind === 'event') lags.set(item.event.item_id, item.event.delivery_lag_ms);

  let lastKnown = -1;

  items.forEach((item, index) => {

    if (item.kind === 'event' && lags.has(item.event.item_id)) lastKnown = index;

  });

  if (lastKnown === -1) return null;

  const next = items.map((item, index) => {

    if (item.kind !== 'event') return item;

    const event = item.event;

    if (lags.has(event.item_id)) {

      const carried = lags.get(event.item_id);

      return carried === undefined ? item : withLag(item, carried);

    }

    if (index < lastKnown || event.own) return item;

    const lag = now - Math.max(event.timestamp_ms, since);

    return lag < FEDERATION_LAG_MS ? item : withLag(item, lag);

  });

  return previous.length === next.length && next.every((item, index) => item === previous[index]) ? previous : next;

}