malice

import { isRecord } from './guards';

import { parseTimelineItem } from './types';

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

export type SearchScope = { kind: 'room'; room_id: string } | { kind: 'rooms'; room_ids: string[] } | { kind: 'all' };

export interface ScopeOption {

  label: string;

  scope: SearchScope;

}

export interface SearchHit {

  room_id: string;

  event_id: string;

  timestamp_ms: number;

  event: TimelineEvent;

  ranges: [number, number][];

}

export interface SearchCoverage {

  room_id: string;

  oldest_indexed_ms: number | null;

  reached_start: boolean;

}

export interface SearchPage {

  hits: SearchHit[];

  next: string | null;

  coverage: SearchCoverage[];

}

/** The wire form of a scope, as macltok's externally tagged enum. */

export function scopeWire(scope: SearchScope): unknown {

  if (scope.kind === 'room') return { Room: scope.room_id };

  if (scope.kind === 'rooms') return { Rooms: scope.room_ids };

  return 'All';

}

function parseRanges(raw: unknown): [number, number][] {

  if (!Array.isArray(raw)) return [];

  return raw.flatMap((range) =>

    Array.isArray(range) && typeof range[0] === 'number' && typeof range[1] === 'number' ? [[range[0], range[1]] as [number, number]] : []

  );

}

function parseHit(raw: unknown): SearchHit | null {

  if (!isRecord(raw) || typeof raw['room_id'] !== 'string' || typeof raw['event_id'] !== 'string') return null;

  const item = parseTimelineItem(raw['preview'] ?? raw['event']);

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

  return {

    room_id: raw['room_id'],

    event_id: raw['event_id'],

    timestamp_ms: typeof raw['timestamp_ms'] === 'number' ? raw['timestamp_ms'] : item.event.timestamp_ms,

    event: item.event,

    ranges: parseRanges(raw['ranges'])

  };

}

function parseCoverage(raw: unknown): SearchCoverage | null {

  if (!isRecord(raw) || typeof raw['room_id'] !== 'string') return null;

  return {

    room_id: raw['room_id'],

    oldest_indexed_ms: typeof raw['oldest_indexed_ms'] === 'number' ? raw['oldest_indexed_ms'] : null,

    reached_start: raw['reached_start'] === true

  };

}

export function parseSearchPage(raw: unknown): SearchPage | null {

  if (!isRecord(raw) || !Array.isArray(raw['hits'])) return null;

  return {

    hits: raw['hits'].flatMap((hit) => parseHit(hit) ?? []),

    next: typeof raw['next'] === 'string' ? raw['next'] : null,

    coverage: Array.isArray(raw['coverage']) ? raw['coverage'].flatMap((c) => parseCoverage(c) ?? []) : []

  };

}

/** Hits grouped by room, keeping the order in which each room first appears. */

export function groupByRoom(hits: SearchHit[]): { room_id: string; hits: SearchHit[] }[] {

  const groups = new Map<string, SearchHit[]>();

  for (const hit of hits) {

    const list = groups.get(hit.room_id);

    if (list) list.push(hit);

    else groups.set(hit.room_id, [hit]);

  }

  return [...groups].map(([room_id, list]) => ({ room_id, hits: list }));

}