export interface PowerLevels {
  ban: number;
  kick: number;
  redact: number;
  events_default: number;
  state_default: number;
  users_default: number;
  users: Map<string, number>;
  events: Map<string, number>;
  creators: Set<string>;
}

function num(raw: Record<string, unknown>, key: string, fallback: number): number {
  const value = raw[key];
  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
}

function pairs(raw: unknown): Map<string, number> {
  const out = new Map<string, number>();
  if (!Array.isArray(raw)) return out;
  for (const entry of raw) {
    if (Array.isArray(entry) && typeof entry[0] === 'string' && typeof entry[1] === 'number') out.set(entry[0], entry[1]);
  }
  return out;
}

export function parsePowerLevels(raw: unknown): PowerLevels | null {
  if (typeof raw !== 'object' || raw === null) return null;
  const o = raw as Record<string, unknown>;
  return {
    ban: num(o, 'ban', 50),
    kick: num(o, 'kick', 50),
    redact: num(o, 'redact', 50),
    events_default: num(o, 'events_default', 0),
    state_default: num(o, 'state_default', 50),
    users_default: num(o, 'users_default', 0),
    users: pairs(o['users']),
    events: pairs(o['events']),
    creators: new Set(Array.isArray(o['creators']) ? o['creators'].filter((c): c is string => typeof c === 'string') : [])
  };
}

export function levelOf(levels: PowerLevels, userId: string): number {
  if (levels.creators.has(userId)) return Infinity;
  return levels.users.get(userId) ?? levels.users_default;
}

export function isMuted(levels: PowerLevels, userId: string): boolean {
  const send = Math.min(levels.events_default, levels.events.get('m.room.message') ?? Infinity);
  return levelOf(levels, userId) < send;
}

export interface Allowed {
  kick: boolean;
  ban: boolean;
  setLevel: boolean;
  maxLevel: number;
}

/** What `self` may do to `target`, per the spec's rule that you can only act on users below you. */
export function allowed(levels: PowerLevels, self: string, target: string): Allowed {
  const mine = levelOf(levels, self);
  const theirs = levelOf(levels, target);
  const outranks = self !== target && mine > theirs;
  const plEvent = levels.events.get('m.room.power_levels') ?? levels.state_default;
  return {
    kick: outranks && mine >= levels.kick,
    ban: outranks && mine >= levels.ban,
    setLevel: (outranks || self === target) && mine >= plEvent,
    maxLevel: mine
  };
}

/** Your own messages need only the redaction event level, anyone else's need `redact` too. */
export function canRedact(levels: PowerLevels, self: string, sender: string): boolean {
  const mine = levelOf(levels, self);
  const send = levels.events.get('m.room.redaction') ?? levels.events_default;
  return mine >= send && (self === sender || mine >= levels.redact);
}

export function roleName(level: number): string | null {
  if (level === Infinity) return 'Creator';
  if (level >= 100) return 'Admin';
  if (level >= 50) return 'Moderator';
  return null;
}

export interface GroupedMember {
  user_id: string;
  name: string;
  display_name: string | null;
  membership: string | { Custom: string };
}

export interface MemberGroup<T> {
  label: string;
  members: T[];
}

const ROLE_ORDER = ['Creator', 'Admin', 'Moderator', 'Members', 'Invited'];

/** Joined members by role, highest level first, then invites. */
export function groupMembers<T extends GroupedMember>(members: T[], levels: PowerLevels | null): MemberGroup<T>[] {
  const level = (m: T) => (levels ? levelOf(levels, m.user_id) : 0);
  const label = (m: T) => (m.membership === 'Invited' ? 'Invited' : (roleName(level(m)) ?? 'Members'));
  const name = (m: T) => (m.display_name || m.name || m.user_id).toLowerCase();
  const sorted = [...members].sort((a, b) => {
    const levelDiff = level(b) - level(a);
    if (!Number.isNaN(levelDiff) && levelDiff !== 0) return levelDiff;
    return name(a).localeCompare(name(b)) || a.user_id.localeCompare(b.user_id);
  });
  const groups = new Map<string, T[]>();
  for (const m of sorted) {
    if (m.membership !== 'Joined' && m.membership !== 'Invited') continue;
    const key = label(m);
    groups.set(key, [...(groups.get(key) ?? []), m]);
  }
  return ROLE_ORDER.filter((key) => groups.has(key)).map((key) => ({ label: key, members: groups.get(key)! }));
}