cinny/src/app/hooks/useReminders.ts

import { useCallback, useEffect, useState } from 'react';
import { ClientEvent, ClientEventHandlerMap, MatrixClient } from 'matrix-js-sdk';
import { useMatrixClient } from './useMatrixClient';
import { getAccountData, setAccountData } from '../utils/accountData';

export type Reminder = {
  roomId: string;
  eventId: string;
  timestamp: number;
  message: string;
};

const REMINDERS_KEY = 'io.lotus.reminders';

type RemindersContent = {
  reminders: Reminder[];
};

function readReminders(mx: MatrixClient): Reminder[] {
  return getAccountData<RemindersContent>(mx, REMINDERS_KEY)?.reminders ?? [];
}

// Module-scoped serialization state.
//
// The latest snapshot and the write queue must be shared across every hook
// instance: ReminderMonitor (auto-removes fired reminders) and RemindMeDialog
// (adds reminders) mount separate hooks, and a per-instance queue would let a
// remove and an add race across instances and clobber each other (setAccountData
// replaces the whole content, no server merge). We therefore keep a single
// shared queue + latest ref, keyed off the active MatrixClient.
type ReminderModuleState = {
  mx: MatrixClient;
  latest: Reminder[];
  writeQueue: Promise<unknown>;
  listeners: Set<(list: Reminder[]) => void>;
  onAccountData: ClientEventHandlerMap[ClientEvent.AccountData];
};

let moduleState: ReminderModuleState | null = null;

// Lazily initialize the shared state for the given client. On a client change
// (login/logout swaps the MatrixClient) we tear down the old subscription and
// re-initialize against the new client so we never leak or double-subscribe.
function ensureModuleState(mx: MatrixClient): ReminderModuleState {
  if (moduleState && moduleState.mx === mx) {
    return moduleState;
  }

  if (moduleState) {
    moduleState.mx.removeListener(ClientEvent.AccountData, moduleState.onAccountData);
  }

  const state: ReminderModuleState = {
    mx,
    latest: readReminders(mx),
    writeQueue: Promise.resolve(),
    listeners: new Set(),
    // Reassigned below once `state` is captured.
    onAccountData: () => undefined,
  };

  state.onAccountData = (evt) => {
    if (evt.getType() === REMINDERS_KEY) {
      const list = evt.getContent<RemindersContent>()?.reminders ?? [];
      state.latest = list;
      state.listeners.forEach((listener) => listener(list));
    }
  };

  mx.on(ClientEvent.AccountData, state.onAccountData);
  moduleState = state;
  return state;
}

function enqueueReminderWrite(
  mx: MatrixClient,
  compute: (current: Reminder[]) => Reminder[],
): Promise<void> {
  const state = ensureModuleState(mx);
  const run = state.writeQueue.then(async () => {
    const next = compute(state.latest);
    state.latest = next;
    state.listeners.forEach((listener) => listener(next));
    await setAccountData(mx, REMINDERS_KEY, { reminders: next });
  });
  // Keep the chain alive even if one write rejects, but propagate the
  // rejection to this caller so it can react (e.g. retry).
  state.writeQueue = run.catch(() => undefined);
  return run;
}

export function useReminders(): {
  reminders: Reminder[];
  addReminder: (r: Reminder) => Promise<void>;
  removeReminder: (eventId: string, timestamp: number) => Promise<void>;
  getReminders: () => Reminder[];
} {
  const mx = useMatrixClient();
  const [reminders, setReminders] = useState<Reminder[]>(() => ensureModuleState(mx).latest);

  // Subscribe to the shared module state. A single AccountData listener is
  // installed per client (in ensureModuleState); each hook instance only
  // registers a local setter and unregisters it on unmount / client change.
  useEffect(() => {
    const state = ensureModuleState(mx);
    setReminders(state.latest);
    state.listeners.add(setReminders);
    return () => {
      state.listeners.delete(setReminders);
    };
  }, [mx]);

  const addReminder = useCallback(
    (r: Reminder) => enqueueReminderWrite(mx, (current) => [...current, r]),
    [mx],
  );

  const removeReminder = useCallback(
    (eventId: string, timestamp: number) =>
      enqueueReminderWrite(mx, (current) =>
        current.filter((r) => !(r.eventId === eventId && r.timestamp === timestamp)),
      ),
    [mx],
  );

  const getReminders = useCallback(() => ensureModuleState(mx).latest, [mx]);

  return { reminders, addReminder, removeReminder, getReminders };
}