import type { RoomSummary } from './types';

export type RoomMode = 'AllMessages' | 'MentionsAndKeywordsOnly' | 'Mute';

export interface MutedSpaces {
  spaces: string[];
  applied: Record<string, Record<string, RoomMode | null>>;
}

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

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function isMode(value: unknown): value is RoomMode {
  return value === 'AllMessages' || value === 'MentionsAndKeywordsOnly' || value === 'Mute';
}

export function parseMutedSpaces(raw: unknown): MutedSpaces {
  if (!isRecord(raw)) return NO_MUTED_SPACES;
  const spaces = Array.isArray(raw['spaces']) ? [...new Set(raw['spaces'].filter((s): s is string => typeof s === 'string'))] : [];
  const applied: MutedSpaces['applied'] = {};
  if (isRecord(raw['applied'])) {
    for (const [spaceId, rooms] of Object.entries(raw['applied'])) {
      if (!spaces.includes(spaceId) || !isRecord(rooms)) continue;
      const entry: Record<string, RoomMode | null> = {};
      for (const [roomId, mode] of Object.entries(rooms)) if (mode === null || isMode(mode)) entry[roomId] = mode;
      applied[spaceId] = entry;
    }
  }
  return { spaces, applied };
}

function childMap(rooms: RoomSummary[]): Map<string, Set<string>> {
  const map = new Map<string, Set<string>>();
  const add = (space: string, child: string) => {
    let set = map.get(space);
    if (!set) map.set(space, (set = new Set()));
    set.add(child);
  };
  for (const room of rooms) {
    for (const child of room.children) add(room.room_id, child);
    for (const parent of room.parent_spaces) add(parent, room.room_id);
  }
  return map;
}

function descendants(spaceId: string, children: Map<string, Set<string>>, spaceIds: Set<string>): Set<string> {
  const out = new Set<string>();
  const seen = new Set<string>([spaceId]);
  const queue = [spaceId];
  for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
    for (const child of children.get(at) ?? []) {
      if (spaceIds.has(child)) {
        if (!seen.has(child)) {
          seen.add(child);
          queue.push(child);
        }
      } else out.add(child);
    }
  }
  return out;
}

export function roomsUnderSpace(spaceId: string, rooms: RoomSummary[]): Set<string> {
  const spaceIds = new Set(rooms.filter((r) => r.space).map((r) => r.room_id));
  return descendants(spaceId, childMap(rooms), spaceIds);
}

export function spaceMutedRoomIds(rooms: RoomSummary[], mutedSpaces: string[]): Set<string> {
  const out = new Set<string>();
  if (mutedSpaces.length === 0) return out;
  const children = childMap(rooms);
  const spaceIds = new Set(rooms.filter((r) => r.space).map((r) => r.room_id));
  for (const id of mutedSpaces) for (const room of descendants(id, children, spaceIds)) out.add(room);
  return out;
}

export function isRoomMuted(room: RoomSummary, spaceMuted: Set<string>): boolean {
  return room.notification_mode === 'Mute' || spaceMuted.has(room.room_id);
}

export function withSpaceMutes(rooms: RoomSummary[], spaceMuted: Set<string>): RoomSummary[] {
  if (spaceMuted.size === 0) return rooms;
  return rooms.map((room) => (spaceMuted.has(room.room_id) && room.notification_mode !== 'Mute' ? { ...room, notification_mode: 'Mute' } : room));
}

export interface RoomChange {
  roomId: string;
  mode: RoomMode | null;
}

export interface Plan {
  state: MutedSpaces;
  changes: RoomChange[];
}

function priorMode(room: RoomSummary): RoomMode | null {
  const mode = room.notification_mode;
  return room.notification_mode_custom && (mode === 'AllMessages' || mode === 'MentionsAndKeywordsOnly') ? mode : null;
}

function claimed(state: MutedSpaces): Set<string> {
  const out = new Set<string>();
  for (const entry of Object.values(state.applied)) for (const roomId of Object.keys(entry)) out.add(roomId);
  return out;
}

function claim(state: MutedSpaces, spaceId: string, targets: RoomSummary[]): Plan {
  const skip = claimed(state);
  const fresh = targets.filter((room) => room.notification_mode !== 'Mute' && room.notification_mode !== null && !skip.has(room.room_id));
  const entry = { ...state.applied[spaceId] };
  for (const room of fresh) entry[room.room_id] = priorMode(room);
  return {
    state: fresh.length === 0 ? state : { ...state, applied: { ...state.applied, [spaceId]: entry } },
    changes: fresh.map((room) => ({ roomId: room.room_id, mode: 'Mute' }))
  };
}

function joinedUnder(spaceId: string, rooms: RoomSummary[]): RoomSummary[] {
  const ids = roomsUnderSpace(spaceId, rooms);
  return rooms.filter((r) => ids.has(r.room_id) && !r.space && r.membership === 'Joined');
}

export function muteSpacePlan(state: MutedSpaces, spaceId: string, rooms: RoomSummary[]): Plan {
  const base = state.spaces.includes(spaceId) ? state : { ...state, spaces: [...state.spaces, spaceId] };
  return claim(base, spaceId, joinedUnder(spaceId, rooms));
}

export function reconcilePlan(state: MutedSpaces, rooms: RoomSummary[]): Plan {
  let current = state;
  const changes: RoomChange[] = [];
  for (const spaceId of state.spaces) {
    const plan = claim(current, spaceId, joinedUnder(spaceId, rooms));
    current = plan.state;
    changes.push(...plan.changes);
  }
  return { state: current, changes };
}

export function unmuteSpacePlan(state: MutedSpaces, spaceId: string, rooms: RoomSummary[]): Plan {
  const spaces = state.spaces.filter((s) => s !== spaceId);
  const { [spaceId]: released = {}, ...applied } = state.applied;
  const next: MutedSpaces = { spaces, applied };
  const byId = new Map(rooms.map((r) => [r.room_id, r]));
  const changes: RoomChange[] = [];
  for (const [roomId, prior] of Object.entries(released)) {
    const room = byId.get(roomId);
    if (!room || room.notification_mode !== 'Mute') continue;
    const heir = spaces.find((s) => roomsUnderSpace(s, rooms).has(roomId));
    if (heir) {
      next.applied = { ...next.applied, [heir]: { ...next.applied[heir], [roomId]: prior } };
      continue;
    }
    changes.push({ roomId, mode: prior });
  }
  return { state: next, changes };
}

export function mutingSpace(state: MutedSpaces, rooms: RoomSummary[], roomId: string): string | null {
  return state.spaces.find((id) => roomsUnderSpace(id, rooms).has(roomId)) ?? null;
}