/**
 * Bed names. A room's beds are either numbered (1, 2, 3 …) or lettered
 * (A, B, C …), and a new bed continues the room's style. One numbered bed is
 * enough to call the room numbered: a desk that renamed A–D to 1–4 and then
 * adds a bed expects 5, not E. Shared by every path that adds beds.
 */

const isNumber = (label: string) => /^\d+$/.test(label.trim());

/**
 * The next free name for a room with these names. `preferNumbers` decides an
 * empty room (or one with only custom names) — dormitories number their beds.
 */
export function nextBedLabel(labels: string[], preferNumbers = false): string {
  const taken = new Set(labels.map((l) => l.trim().toLowerCase()));
  const numbers = labels.filter(isNumber).map(Number);
  // A room already lettered (A, B …) carries on with letters; `preferNumbers`
  // only decides a room with no style yet.
  const lettered = labels.some((l) => /^[A-Za-z]$/.test(l.trim()));
  if (numbers.length || (preferNumbers && !lettered)) {
    let n = numbers.length ? Math.max(...numbers) + 1 : 1;
    while (taken.has(String(n))) n++;
    return String(n);
  }
  for (let i = 0; i < 26; i++) {
    const l = String.fromCharCode(65 + i);
    if (!taken.has(l.toLowerCase())) return l;
  }
  // Past Z, carry on with numbers.
  let n = labels.length + 1;
  while (taken.has(String(n))) n++;
  return String(n);
}

/** `count` new names in a row, each continuing from the last. */
export function nextBedLabels(labels: string[], count: number, preferNumbers = false): string[] {
  const all = [...labels];
  const out: string[] = [];
  for (let i = 0; i < count; i++) {
    const l = nextBedLabel(all, preferNumbers);
    out.push(l);
    all.push(l);
  }
  return out;
}

/** Natural order: 1, 2, … 9, 10 (not 1, 10, 2), then A, B, C. */
export const compareBedLabels = (a: string, b: string) => a.localeCompare(b, 'en', { numeric: true, sensitivity: 'base' });

export function sortBeds<T extends { label: string }>(beds: T[]): T[] {
  return [...beds].sort((x, y) => compareBedLabels(x.label, y.label));
}

/**
 * Compact a previously sequential set after one bed is removed. Custom names
 * are deliberately left alone: only 1..N (with at most one gap) and A..N
 * qualify, so deleting “Window” never renames the other beds.
 *
 * The input must already be in natural bed order. Null means it is not a
 * sequence managed by the app and must not be changed.
 */
export function resequencedBedLabels(labels: string[]): string[] | null {
  if (labels.length === 0) return [];
  const trimmed = labels.map((label) => label.trim());
  if (trimmed.every((label) => /^\d+$/.test(label))) {
    const values = trimmed.map(Number);
    if (new Set(values).size !== values.length || values.some((value) => value < 1 || value > labels.length + 1)) return null;
    return labels.map((_, index) => String(index + 1));
  }
  if (trimmed.every((label) => /^[A-Za-z]$/.test(label))) {
    const values = trimmed.map((label) => label.toUpperCase().charCodeAt(0) - 64);
    if (new Set(values).size !== values.length || values.some((value) => value < 1 || value > labels.length + 1)) return null;
    return labels.map((_, index) => String.fromCharCode(65 + index));
  }
  return null;
}
