malice

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

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

import { pushBanner, sessionUser, 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], ([$timelines, $pinned]) => {

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

  for (const roomId of new Set([...Object.keys($timelines), ...Object.keys($pinned)])) {

    const list = roomThreads(roomId, $timelines[roomId] ?? [], $pinned[roomId] ?? []);

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

  }

  return out;

});

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;

  opened = null;

  openThread.set(null);

  pinnedThreads.set({});

});