malice

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

import { closeThreadList, getAccountData, openThreadList, paginateThreadList, runCommand, setAccountData } from './api';

import { pushBanner, rooms, sessionUser, threadLists, timelines } from './store';

import { roomThreads } from './thread-index';

import type { ThreadEntry } from './thread-index';

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

const PINNED_TYPE = 'dev.malice.pinned_threads';

export interface OpenThread {

  room_id: string;

  root_event_id: string;

  focus_event_id?: string;

}

export const openThread = writable<OpenThread | null>(null);

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

const NO_TIMELINE: TimelineItem[] = [];

const NO_PINS: string[] = [];

const NO_ENTRIES: ThreadListEntry[] = [];

const NO_UNREADS: Record<string, ThreadUnread> = {};

interface RoomThreadsCache {

  timeline: TimelineItem[];

  pins: string[];

  entries: ThreadListEntry[];

  unreads: Record<string, ThreadUnread>;

  list: ThreadEntry[];

}

function createThreadsByRoom() {

  let cache = new Map<string, RoomThreadsCache>();

  let last: Record<string, ThreadEntry[]> = {};

  const computed = derived([timelines, pinnedThreads, threadLists, rooms], ([$timelines, $pinned, $lists, $rooms]) => {

    const unreads = new Map($rooms.map((room) => [room.room_id, room.thread_unreads]));

    const next = new Map<string, RoomThreadsCache>();

    const out: Record<string, ThreadEntry[]> = {};

    const ids = [...Object.keys($timelines), ...Object.keys($pinned), ...Object.keys($lists), ...unreads.keys()];

    for (const roomId of new Set(ids)) {

      const timeline = $timelines[roomId] ?? NO_TIMELINE;

      const pins = $pinned[roomId] ?? NO_PINS;

      const entries = $lists[roomId]?.entries ?? NO_ENTRIES;

      const roomUnreads = unreads.get(roomId) ?? NO_UNREADS;

      const hit = cache.get(roomId);

      const reuse = hit && hit.timeline === timeline && hit.pins === pins && hit.entries === entries && hit.unreads === roomUnreads;

      const entry = reuse ? hit : { timeline, pins, entries, unreads: roomUnreads, list: roomThreads(roomId, timeline, pins, entries, roomUnreads) };

      next.set(roomId, entry);

      if (entry.list.length) out[roomId] = entry.list;

    }

    const keys = Object.keys(out);

    const unchanged = keys.length === Object.keys(last).length && keys.every((roomId) => out[roomId] === last[roomId]);

    cache = next;

    if (unchanged) return last;

    last = out;

    return out;

  });

  return readable(last, (set) => {

    let sent: Record<string, ThreadEntry[]> | null = null;

    return computed.subscribe((value) => {

      if (value === sent) return;

      sent = value;

      set(value);

    });

  });

}

export const threadsByRoom = createThreadsByRoom();

const THREAD_PAGE = 20;

const openLists = new Set<string>();

/** Keeps a server thread list open for exactly the rooms in `wanted`, loading a first page for each new one. */

export function syncThreadLists(wanted: string[]): void {

  const want = new Set(wanted);

  for (const roomId of [...openLists]) {

    if (want.has(roomId)) continue;

    openLists.delete(roomId);

    void closeThreadList(roomId).catch(() => undefined);

  }

  for (const roomId of want) {

    if (openLists.has(roomId)) continue;

    openLists.add(roomId);

    void openThreadList(roomId)

      .then(() => paginateThreadList(roomId, THREAD_PAGE))

      .catch(() => openLists.delete(roomId));

  }

}

export async function loadOlderThreads(roomId: string): Promise<void> {

  try {

    await paginateThreadList(roomId, THREAD_PAGE);

  } catch (e) {

    pushBanner(e instanceof Error ? e.message : 'Could not load older threads');

  }

}

function parsePinned(raw: unknown): Record<string, string[]> {

  if (typeof raw !== 'object' || raw === null) return {};

  const rooms = (raw as Record<string, unknown>)['rooms'];

  if (typeof rooms !== 'object' || rooms === null) return {};

  const out: Record<string, string[]> = {};

  for (const [roomId, list] of Object.entries(rooms)) {

    if (Array.isArray(list)) out[roomId] = list.filter((id): id is string => typeof id === 'string');

  }

  return out;

}

export async function loadPinnedThreads(): Promise<void> {

  try {

    pinnedThreads.set(parsePinned(await getAccountData(PINNED_TYPE)));

  } catch {

    pinnedThreads.set({});

  }

}

export async function togglePinnedThread(roomId: string, rootEventId: string): Promise<void> {

  const before = get(pinnedThreads);

  const list = before[roomId] ?? [];

  const nextList = list.includes(rootEventId) ? list.filter((id) => id !== rootEventId) : [...list, rootEventId];

  const next = { ...before, [roomId]: nextList };

  if (nextList.length === 0) delete next[roomId];

  pinnedThreads.set(next);

  try {

    await setAccountData(PINNED_TYPE, { rooms: next });

  } catch (e) {

    pinnedThreads.set(before);

    pushBanner(e instanceof Error ? e.message : 'Pinning the thread failed');

  }

}

let opened: OpenThread | null = null;

/** The room must already be open, since macltok builds thread timelines inside it. */

export async function showThread(target: OpenThread | null): Promise<void> {

  const previous = opened;

  opened = target;

  openThread.set(target);

  if (previous && target && previous.room_id === target.room_id && previous.root_event_id === target.root_event_id) return;

  if (previous) runCommand({ op: 'close_thread', room_id: previous.room_id, root_event_id: previous.root_event_id }).catch(() => undefined);

  if (!target) return;

  try {

    await runCommand({ op: 'open_thread', room_id: target.room_id, root_event_id: target.root_event_id });

  } catch (e) {

    if (opened === target) {

      opened = null;

      openThread.set(null);

    }

    pushBanner(e instanceof Error ? e.message : 'Opening the thread failed');

  }

}

let account: string | null | undefined;

sessionUser.subscribe((user) => {

  if (user === account) return;

  account = user;

  openLists.clear();

  opened = null;

  openThread.set(null);

  pinnedThreads.set({});

});