malice

import { derived, get, 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';

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[]>>({});

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

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

  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 list = roomThreads(roomId, $timelines[roomId] ?? [], $pinned[roomId] ?? [], $lists[roomId]?.entries ?? [], unreads.get(roomId) ?? {});

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

  }

  return out;

});

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({});

});