malice

import { parseEventContext, parseTimelineItem } from './types';

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

export interface MentionKey { room_id: string; event_id: string }

export type MentionReason = 'Direct' | 'Reply' | 'Room' | 'Keyword';

export type MentionCaptureState =

  | { kind: 'Pending' | 'Partial' | 'Ready' | 'Unavailable' }

  | { kind: 'Failed'; message: string; retry_at_ms: number };

export interface MentionEntry {

  key: MentionKey; timestamp_ms: number; discovered_at_ms: number; discovery_revision: number; revision: number;

  event: TimelineItem; reasons: MentionReason[]; read: boolean; capture: MentionCaptureState;

  room_name: string | null; notification_suppressed: boolean;

}

export interface MentionCoverage {

  earliest_timestamp_ms: number | null; historical_supported: boolean | null; recovering: boolean;

  gaps: MentionGap[]; truncated: boolean; unresolved_candidates: number;

}

export interface MentionGap { room_id: string | null; reason: string; token: string | null }

export interface MentionsBoundary { account: string; revision: number }

export interface MentionsPage {

  entries: MentionEntry[]; next_cursor: string | null; end_reached: boolean; coverage: MentionCoverage;

  unread_count: number; revision: number; boundary: MentionsBoundary;

}

export interface SavedMentionContext { key: MentionKey; state: MentionCaptureState; context: EventContext | null; revision: number }

export interface MentionsUpdate { snapshot: MentionsPage; upserts: MentionEntry[]; removed: MentionKey[] }

type Obj = Record<string, unknown>;

const obj = (v: unknown): v is Obj => typeof v === 'object' && v !== null && !Array.isArray(v);

const str = (v: unknown): v is string => typeof v === 'string';

const bool = (v: unknown): v is boolean => typeof v === 'boolean';

const nat = (v: unknown): v is number => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;

function key(v: unknown): MentionKey | null {

  if (!obj(v) || !str(v.room_id) || !v.room_id || !str(v.event_id) || !v.event_id) return null;

  return { room_id: v.room_id, event_id: v.event_id };

}

function capture(v: unknown): MentionCaptureState | null {

  if (str(v) && ['Pending', 'Partial', 'Ready', 'Unavailable'].includes(v)) return { kind: v as 'Pending' | 'Partial' | 'Ready' | 'Unavailable' };

  if (obj(v) && obj(v.Failed) && str(v.Failed.message) && nat(v.Failed.retry_at_ms)) return { kind: 'Failed', message: v.Failed.message, retry_at_ms: v.Failed.retry_at_ms };

  return null;

}

function entry(v: unknown): MentionEntry | null {

  if (!obj(v)) return null;

  const k = key(v.key), ev = parseTimelineItem(v.event), c = capture(v.capture);

  if (!k || !ev || !c || !nat(v.timestamp_ms) || !nat(v.discovered_at_ms) || !nat(v.discovery_revision) || !nat(v.revision) || !Array.isArray(v.reasons) || !v.reasons.every(x => str(x) && ['Direct','Reply','Room','Keyword'].includes(x)) || !bool(v.read) || !(v.room_name === null || str(v.room_name)) || !bool(v.notification_suppressed)) return null;

  return { key:k, timestamp_ms:v.timestamp_ms, discovered_at_ms:v.discovered_at_ms, discovery_revision:v.discovery_revision, revision:v.revision, event:ev, reasons:v.reasons as MentionReason[], read:v.read, capture:c, room_name:v.room_name, notification_suppressed:v.notification_suppressed };

}

function gap(v: unknown): MentionGap | null {

  if (!obj(v) || !(v.room_id === null || (str(v.room_id) && v.room_id)) || !str(v.reason) || !(v.token === null || str(v.token))) return null;

  return { room_id:v.room_id, reason:v.reason, token:v.token };

}

function page(v: unknown): MentionsPage | null {

  if (!obj(v) || !obj(v.coverage) || !Array.isArray(v.entries) || !Array.isArray(v.coverage['gaps'])) return null;

  const entries=v.entries.map(entry), cov=v.coverage as Obj;

  const gaps=(cov['gaps'] as unknown[]).map(gap);

  if (entries.some(x=>!x) || gaps.some(x=>!x) || !(v.next_cursor === null || str(v.next_cursor)) || !bool(v.end_reached) || !(cov['earliest_timestamp_ms'] === null || nat(cov['earliest_timestamp_ms'])) || !(cov['historical_supported'] === null || bool(cov['historical_supported'])) || !bool(cov['recovering']) || !bool(cov['truncated']) || !nat(cov['unresolved_candidates']) || !nat(v.unread_count) || !nat(v.revision) || !obj(v.boundary) || !str(v.boundary['account']) || !v.boundary['account'] || !nat(v.boundary['revision'])) return null;

  return { entries:entries as MentionEntry[], next_cursor:v.next_cursor as string|null, end_reached:v.end_reached, coverage:{earliest_timestamp_ms:cov['earliest_timestamp_ms'] as number|null,historical_supported:cov['historical_supported'] as boolean|null,recovering:cov['recovering'],gaps:gaps as MentionGap[],truncated:cov['truncated'],unresolved_candidates:cov['unresolved_candidates']}, unread_count:v.unread_count, revision:v.revision, boundary:{account:v.boundary['account'],revision:v.boundary['revision']} };

}

export function parseMentionsPage(raw: unknown): MentionsPage | null { try { return page(raw); } catch { return null; } }

export function parseSavedMentionContext(raw: unknown): SavedMentionContext | null {

  try {

    if (!obj(raw)) return null;

    const k=key(raw.key), state=capture(raw.state), context=raw.context === null ? null : parseEventContext(raw.context);

    if (!k || !state || (raw.context !== null && !context) || !nat(raw.revision)) return null;

    return {key:k,state,context,revision:raw.revision};

  } catch { return null; }

}

export function parseMentionsUpdate(raw: unknown): MentionsUpdate | null {

  try {

    if (!obj(raw) || !Array.isArray(raw.upserts) || !Array.isArray(raw.removed)) return null;

    const snapshot=page(raw.snapshot), upserts=raw.upserts.map(entry), removed=raw.removed.map(key);

    if (!snapshot || upserts.some(x=>!x) || removed.some(x=>!x)) return null;

    return {snapshot,upserts:upserts as MentionEntry[],removed:removed as MentionKey[]};

  } catch { return null; }

}

export function mentionKey(key: MentionKey): string { return JSON.stringify([key.room_id,key.event_id]); }