malice

import assert from 'node:assert/strict';

import { test } from 'node:test';

import {

  isRoomMuted,

  muteSpacePlan,

  mutingSpace,

  parseMutedSpaces,

  reconcilePlan,

  spaceMutedRoomIds,

  unmuteSpacePlan,

  withSpaceMutes,

  type MutedSpaces

} from '../src/lib/mute-model.ts';

import { badgeTotal } from '../src/lib/notification-model.ts';

import type { RoomSummary } from '../src/lib/types.ts';

function room(id: string, extra: Partial<RoomSummary> = {}): RoomSummary {

  return {

    room_id: id,

    name: id,

    membership: 'Joined',

    space: false,

    direct: false,

    unread_messages: 0,

    unread_mentions: 0,

    notification_mode: 'AllMessages',

    notification_mode_custom: false,

    parent_spaces: [],

    children: [],

    ...extra

  } as RoomSummary;

}

const empty: MutedSpaces = { spaces: [], applied: {} };

const rooms = [

  room('!top', { space: true, children: ['!a', '!sub'] }),

  room('!sub', { space: true, parent_spaces: ['!top'], children: ['!b'] }),

  room('!a', { parent_spaces: ['!top'], unread_messages: 3 }),

  room('!b', { parent_spaces: ['!sub'], unread_messages: 2, notification_mode: 'MentionsAndKeywordsOnly', notification_mode_custom: true }),

  room('!c', { notification_mode: 'Mute', notification_mode_custom: true, parent_spaces: ['!top'] }),

  room('!other', { unread_messages: 1 })

];

test('space mute covers nested rooms but not rooms elsewhere', () => {

  assert.deepEqual([...spaceMutedRoomIds(rooms, ['!top'])].sort(), ['!a', '!b', '!c']);

  assert.equal(spaceMutedRoomIds(rooms, []).size, 0);

});

test('space mute silences the badge total and leaves other rooms', () => {

  const muted = withSpaceMutes(rooms, spaceMutedRoomIds(rooms, ['!top']));

  assert.equal(badgeTotal(muted), 1);

  assert.equal(badgeTotal(rooms), 4);

  assert.equal(withSpaceMutes(rooms, new Set()), rooms);

});

test('isRoomMuted covers explicit and inherited mute', () => {

  const inherited = spaceMutedRoomIds(rooms, ['!top']);

  assert.equal(isRoomMuted(rooms[2], inherited), true);

  assert.equal(isRoomMuted(rooms[5], inherited), false);

  assert.equal(isRoomMuted(rooms[4], new Set()), true);

});

test('muting a space claims unmuted children with their prior mode', () => {

  const plan = muteSpacePlan(empty, '!top', rooms);

  assert.deepEqual(plan.state.spaces, ['!top']);

  assert.deepEqual(plan.state.applied['!top'], { '!a': null, '!b': 'MentionsAndKeywordsOnly' });

  assert.deepEqual(plan.changes.map((c) => c.roomId).sort(), ['!a', '!b']);

});

test('unmuting restores prior modes and leaves individual mutes alone', () => {

  const muted = muteSpacePlan(empty, '!top', rooms).state;

  const after = rooms.map((r) => (r.room_id === '!a' || r.room_id === '!b' ? { ...r, notification_mode: 'Mute' as const } : r));

  const plan = unmuteSpacePlan(muted, '!top', after);

  assert.deepEqual(plan.state, empty);

  assert.deepEqual(plan.changes, [

    { roomId: '!a', mode: null },

    { roomId: '!b', mode: 'MentionsAndKeywordsOnly' }

  ]);

  assert.equal(plan.changes.some((c) => c.roomId === '!c'), false);

});

test('a room a user unmuted inside a muted space is not reclaimed', () => {

  const muted = muteSpacePlan(empty, '!top', rooms).state;

  const after = rooms.map((r) => (r.room_id === '!a' ? { ...r, notification_mode: 'AllMessages' as const } : r));

  assert.deepEqual(reconcilePlan(muted, after).changes, []);

});

test('reconcile mutes children that joined later', () => {

  const muted = muteSpacePlan(empty, '!top', rooms).state;

  const joined = [...rooms, room('!new', { parent_spaces: ['!top'] })];

  const plan = reconcilePlan(muted, joined);

  assert.deepEqual(plan.changes, [{ roomId: '!new', mode: 'Mute' }]);

  assert.equal(reconcilePlan(plan.state, joined).changes.length, 0);

});

test('reconcile ignores rooms whose mode has not loaded', () => {

  const muted: MutedSpaces = { spaces: ['!top'], applied: {} };

  const pending = rooms.map((r) => (r.room_id === '!a' ? { ...r, notification_mode: null } : r));

  assert.equal(reconcilePlan(muted, pending).changes.some((c) => c.roomId === '!a'), false);

});

test('overlapping muted spaces hand the room to the remaining space on unmute', () => {

  const both = [...rooms, room('!shared', { parent_spaces: ['!top', '!x'] }), room('!x', { space: true, children: ['!shared'] })];

  let state = muteSpacePlan(empty, '!top', both).state;

  state = muteSpacePlan(state, '!x', both).state;

  const after = both.map((r) => (r.notification_mode === 'AllMessages' ? { ...r, notification_mode: 'Mute' as const } : r));

  const plan = unmuteSpacePlan(state, '!top', after);

  assert.equal(plan.changes.some((c) => c.roomId === '!shared'), false);

  assert.ok('!shared' in (plan.state.applied['!x'] ?? {}));

  assert.equal(mutingSpace(plan.state, after, '!shared'), '!x');

});

test('parseMutedSpaces tolerates junk', () => {

  assert.deepEqual(parseMutedSpaces(null), empty);

  assert.deepEqual(parseMutedSpaces({ spaces: ['!a', 3], applied: { '!a': { '!r': 'Mute', '!q': 'Bogus' }, '!gone': { '!r': null } } }), {

    spaces: ['!a'],

    applied: { '!a': { '!r': 'Mute' } }

  });

});