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;
}