malice

import { get, writable } from 'svelte/store';

import { sendMessage } from './api';

import { formatBody } from './markdown';

import { timelines } from './store';

import type { Mention } from './mentions';

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

export interface PendingMessage {

  id: string;

  body: string;

  formatted: string | null;

  replyTo: ReplyReference | null;

  status: 'sending' | 'failed';

  error: string | null;

  createdAt: number;

}

export const pendingByRoom = writable<Record<string, PendingMessage[]>>({});

interface PendingRecord extends PendingMessage {

  roomId: string;

  mentions: Mention[];

  markdown: boolean;

  knownIds: Set<string>;

}

const records = new Map<string, PendingRecord>();

const queues = new Map<string, Promise<void>>();

let nextSeq = 1;

function nextId(): string {

  return `pending-${nextSeq++}`;

}

function ownIdentities(items: TimelineItem[]): Set<string> {

  const out = new Set<string>();

  for (const item of items) {

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

    const id = item.event.transaction_id ?? item.event.event_id;

    if (id) out.add(id);

  }

  return out;

}

function toPublic(record: PendingRecord): PendingMessage {

  return { id: record.id, body: record.body, formatted: record.formatted, replyTo: record.replyTo, status: record.status, error: record.error, createdAt: record.createdAt };

}

function roomList(roomId: string): PendingMessage[] {

  return get(pendingByRoom)[roomId] ?? [];

}

function setRoom(roomId: string, list: PendingMessage[]): void {

  pendingByRoom.update((all) => ({ ...all, [roomId]: list }));

}

function addRecord(record: PendingRecord): void {

  records.set(record.id, record);

  setRoom(record.roomId, [...roomList(record.roomId), toPublic(record)]);

}

function updateRecord(id: string, patch: Partial<Pick<PendingRecord, 'status' | 'error'>>): void {

  const record = records.get(id);

  if (!record) return;

  Object.assign(record, patch);

  setRoom(record.roomId, roomList(record.roomId).map((p) => (p.id === id ? toPublic(record) : p)));

}

function removeRecord(id: string): void {

  const record = records.get(id);

  if (!record) return;

  records.delete(id);

  setRoom(record.roomId, roomList(record.roomId).filter((p) => p.id !== id));

}

async function attemptSend(record: PendingRecord): Promise<void> {

  if (!records.has(record.id)) return;

  updateRecord(record.id, { status: 'sending', error: null });

  try {

    await sendMessage(record.roomId, record.body, record.replyTo?.event_id ?? null, record.mentions, record.markdown);

  } catch (e) {

    updateRecord(record.id, { status: 'failed', error: e instanceof Error ? e.message : 'Message could not be sent' });

  }

}

function enqueue(record: PendingRecord): void {

  const previous = queues.get(record.roomId) ?? Promise.resolve();

  const next = previous.then(() => attemptSend(record));

  queues.set(record.roomId, next.catch(() => undefined));

}

export function queueSend(

  roomId: string,

  body: string,

  replyTo: ReplyReference | null = null,

  mentions: Mention[] = [],

  markdown = false

): void {

  const record: PendingRecord = {

    id: nextId(),

    roomId,

    body,

    formatted: formatBody(body, mentions, markdown),

    replyTo,

    mentions,

    markdown,

    status: 'sending',

    error: null,

    createdAt: Date.now(),

    knownIds: ownIdentities(get(timelines)[roomId] ?? [])

  };

  addRecord(record);

  enqueue(record);

}

export function retryPending(id: string): void {

  const record = records.get(id);

  if (!record) return;

  record.knownIds = ownIdentities(get(timelines)[record.roomId] ?? []);

  enqueue(record);

}

export function discardPending(id: string): void {

  removeRecord(id);

}

export function resetPending(): void {

  records.clear();

  queues.clear();

  pendingByRoom.set({});

}

function reconcileRoom(roomId: string, items: TimelineItem[]): void {

  const list = roomList(roomId);

  if (list.length === 0) return;

  const ownItems = items.filter((item) => item.kind === 'event' && item.event.own) as Extract<

    TimelineItem,

    { kind: 'event' }

  >[];

  const claimed = new Set<string>();

  for (const pending of list) {

    const record = records.get(pending.id);

    if (!record) continue;

    const match = ownItems.find((item) => {

      if (claimed.has(item.event.item_id)) return false;

      const id = item.event.transaction_id ?? item.event.event_id;

      if (id && record.knownIds.has(id)) return false;

      return item.event.content.kind === 'Message' && item.event.content.message.body === record.body;

    });

    if (match) {

      claimed.add(match.event.item_id);

      removeRecord(record.id);

    }

  }

}

timelines.subscribe((all) => {

  for (const roomId of Object.keys(get(pendingByRoom))) {

    reconcileRoom(roomId, all[roomId] ?? []);

  }

});