import { derived, get } from 'svelte/store';
import { runCommand, setAccountData } from './api';
import {
  muteSpacePlan,
  reconcilePlan,
  spaceMutedRoomIds,
  unmuteSpacePlan,
  withSpaceMutes,
  type Plan,
  type RoomMode
} from './mute-model';
import { MUTED_SPACES_EVENT, mutedSpaces, mutedSpacesLoaded } from './muted-spaces';
import { rooms } from './store';

export const spaceMutedRooms = derived([rooms, mutedSpaces], ([$rooms, $muted]) => spaceMutedRoomIds($rooms, $muted.spaces));

export const effectiveRooms = derived([rooms, spaceMutedRooms], ([$rooms, $muted]) => withSpaceMutes($rooms, $muted));

let queue: Promise<void> = Promise.resolve();

export function setRoomMode(roomId: string, mode: RoomMode | null): Promise<void> {
  return runCommand({ op: 'set_room_notification_mode', room_id: roomId, mode }).then(() => undefined);
}

async function apply(plan: Plan): Promise<void> {
  await setAccountData(MUTED_SPACES_EVENT, { ...plan.state });
  mutedSpaces.set(plan.state);
  const results = await Promise.allSettled(plan.changes.map((c) => setRoomMode(c.roomId, c.mode)));
  const failed = results.find((r): r is PromiseRejectedResult => r.status === 'rejected');
  if (failed) throw failed.reason;
}

function enqueue(job: () => Promise<void>): Promise<void> {
  const run = queue.then(job);
  queue = run.catch(() => undefined);
  return run;
}

export function setSpaceMuted(spaceId: string, muted: boolean): Promise<void> {
  return enqueue(async () => {
    const state = get(mutedSpaces);
    const all = get(rooms);
    await apply(muted ? muteSpacePlan(state, spaceId, all) : unmuteSpacePlan(state, spaceId, all));
  });
}

export function startMuteSync(): () => void {
  const reconcile = () => {
    if (!mutedSpacesLoaded() || get(mutedSpaces).spaces.length === 0) return;
    void enqueue(async () => {
      const plan = reconcilePlan(get(mutedSpaces), get(rooms));
      if (plan.changes.length > 0) await apply(plan);
    }).catch(() => undefined);
  };
  const stopRooms = rooms.subscribe(reconcile);
  const stopMuted = mutedSpaces.subscribe(reconcile);
  return () => {
    stopRooms();
    stopMuted();
  };
}