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;
}