malice

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

export interface ThreadEntry {

  room_id: string;

  root_event_id: string;

  preview: string;

  sender: string;

  reply_count: number;

  latest_ms: number;

  pinned: boolean;

}

function previewOf(event: TimelineEvent): string {

  const content = event.content;

  if (content.kind === 'Message') return content.message.media?.caption ?? content.message.body;

  if (content.kind === 'Sticker') return content.body || 'Sticker';

  if (content.kind === 'Poll') return content.question;

  return '';

}

function entryFor(roomId: string, event: TimelineEvent, pinned: boolean): ThreadEntry | null {

  if (!event.event_id || event.thread_root) return null;

  return {

    room_id: roomId,

    root_event_id: event.event_id,

    preview: previewOf(event),

    sender: event.sender.display_name ?? event.sender.user_id,

    reply_count: event.thread_summary?.reply_count ?? 0,

    latest_ms: event.thread_summary?.latest_event_timestamp_ms ?? event.timestamp_ms,

    pinned

  };

}

/** Pinned threads first, then by latest activity. Pins whose root isn't loaded still get a row. */

export function roomThreads(roomId: string, items: TimelineItem[], pinnedRoots: string[]): ThreadEntry[] {

  const pinned = new Set(pinnedRoots);

  const found = new Map<string, ThreadEntry>();

  for (const item of items) {

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

    const id = item.event.event_id;

    if (!id || (!pinned.has(id) && (item.event.thread_summary?.reply_count ?? 0) === 0)) continue;

    const entry = entryFor(roomId, item.event, pinned.has(id));

    if (entry) found.set(id, entry);

  }

  for (const root of pinnedRoots) {

    if (!found.has(root)) {

      found.set(root, { room_id: roomId, root_event_id: root, preview: '', sender: '', reply_count: 0, latest_ms: 0, pinned: true });

    }

  }

  return [...found.values()].sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.latest_ms - a.latest_ms);

}

export function threadMatches(entry: ThreadEntry, query: string): boolean {

  if (!query) return true;

  return entry.preview.toLowerCase().includes(query) || entry.sender.toLowerCase().includes(query);

}