const BASE_ROOM_SIZE = 4025;
const boxSize = 25;
const arcLenghtBetween2Chairs = 2 * boxSize;
const PI = Math.PI;
const DEG_TO_RAD = PI / 180;
const RAD_TO_DEG = 180 / PI;
const GAP_CHAIR_TABLE = 25;

type Brand<T, B extends string> = T & { readonly __brand: B };

type TableId = Brand<string, "TableId">;
type ChairId = Brand<string, "ChairId">;
type GuestId = Brand<string, "GuestId">;
type GroupId = Brand<string, "GroupId">;
type RoomId = Brand<string, "RoomId">;

// Object.keys() is typed string[] for soundness (an object can structurally have
// extra keys at runtime); this trades that theoretical gap for keeping our actual
// id types on dictionary keys everywhere we iterate them.
const objectKeys = <T extends object>(obj: T): (keyof T)[] => Object.keys(obj) as (keyof T)[];

type ColorToken =
  | "purple"
  | "green"
  | "red"
  | "gold"
  | "blue"
  | "pink"
  | "orange"
  | "wine"
  | "teal"
  | "indigo"
  | "grey"
  | "black";
type ChairType = "top" | "right" | "bottom" | "left" | "round";
type ChairSpot = {
  chairId: ChairId;
  tableId: TableId;
  isChair: boolean;
  chairType: ChairType;
  chairNr: number;
  isHidden?: boolean;
};
// The number in a minted id ("guest_12" → 12), or undefined for any other id.
// Ids are "<prefix><counter>", so this is also an entity's creation order.
const idNumber = (id: string, prefix: string): number | undefined => {
  if (!id.startsWith(prefix)) return undefined;
  const digits = id.slice(prefix.length);
  // Plain digits only ("1e308" would pass Number() and freeze a counter).
  if (!/^\d+$/.test(digits)) return undefined;
  const number = Number(digits);
  return Number.isSafeInteger(number) ? number : undefined;
};

type Table = {
  tableId: TableId;
  type: "square" | "round" | "bench";
  label: string;
  colorToken: ColorToken;
  zIndex: number;

  centerX: number;
  centerY: number;
  height: number;
  width: number;
  rotate: number;
};
type Guest = {
  guestId: GuestId;
  name: string;

  likes: GuestId[];
  dislikes: GuestId[];

  // Chair preferences only make sense within one room's layout, so they're
  // keyed per room even though the guest itself is shared across all rooms.
  allowedChairsByRoom: { [roomId: RoomId]: ChairId[] };
  notAllowedChairsByRoom: { [roomId: RoomId]: ChairId[] };
};
enum NavigationStep {
  build = 1,
  guest = 2,
  arrange = 3,
  // The export overlay (PDF / guests' page), laid over step 3's seating.
  share = 4,
}

type Room = {
  roomId: RoomId;
  roomName: string;
  tables: { [tableId: TableId]: Table };
  chairSpots: { [chairId: ChairId]: ChairSpot };
  placement: { [guestId: GuestId]: ChairId };
  zoom: number;
  scrollLeft: number;
  scrollTop: number;
  // How many tables this room has had: the next one's default label (A, B,
  // C …), colour and z-index come from it. Not an id — ids are random
  // (ids.ts).
  nextTableNumber: number;
};
const allRooms: { [roomId: RoomId]: Room } = {};
const roomOrder: RoomId[] = [];
let currentRoomId: RoomId = "" as RoomId;

// These always point at allRooms[currentRoomId]'s own tables/chairSpots/placement.
// Switching rooms reassigns them rather than rekeying every call site that reads them.
let allTables: Room["tables"] = {};
let allChairSpots: Room["chairSpots"] = {};
const allGuests: { [guestId: GuestId]: Guest } = {};
let placement: Room["placement"] = {};

type Group = {
  groupId: GroupId;
  groupName: string;
  guestIds: GuestId[];

  mustSitTogether: boolean;

  likes: GuestId[];
  dislikes: GuestId[];

  allowedChairsByRoom: { [roomId: RoomId]: ChairId[] };
  notAllowedChairsByRoom: { [roomId: RoomId]: ChairId[] };
};
const allGroups: { [groupId: GroupId]: Group } = {};

// Pure ordering of the guest list: either a lone guest, or a group (whose
// name/members/preferences live in allGroups, keyed by the same groupId).
type GuestOrderEntry = { isGroup: false; guestId: GuestId } | { isGroup: true; groupId: GroupId };
const guestOrder: GuestOrderEntry[] = [];

const colorMap: ColorToken[] = [
  "purple",
  "green",
  "red",
  "gold",
  "blue",
  "pink",
  "orange",
  "wine",
  "teal",
  "indigo",
  "grey",
  "black",
];

type RoomMode = "buildMode" | "preferenceMode" | "placementMode";

let draggableSelector: JQuery<HTMLElement> | undefined = undefined;
let resizeSelector: JQuery<HTMLElement> | undefined = undefined;
let rotateSelector: JQuery<HTMLElement> | undefined = undefined;
let guestBallSelector: JQuery<HTMLElement> | undefined = undefined;
let guestBallSelectorType: "List" | "Chair" = "List";
let guestBallGrabX = 0;
let guestBallGrabY = 0;
let guestBallGrabScale = 1;
let rowSelector: JQuery<HTMLElement> | undefined = undefined;
let cursor: "rotate" | "resize" | "move" | "default" = "default";
let roomMode: RoomMode = "buildMode";
let currentStep: NavigationStep = NavigationStep.build;
let moveRoom = false;
let startRoomScrollLeft = 0;
let startRoomScrollTop = 0;
let activeResize: ResizeDirection = { ns: "", ew: "", type: "square" };
// Raw viewport pixels (e.clientX/clientY) — for positioning the fixed custom-cursor
// overlay and for room-panning math, which both operate in on-screen pixel space.
let viewportMouseX = 0;
let viewportMouseY = 0;
let viewportMouseDownX = 0;
let viewportMouseDownY = 0;
// Room-space pixels (post mouseSpaceToRoomSpace: unzoomed, scroll-independent) —
// same coordinate space as Table.centerX/centerY. Used for all table/chair geometry math.
let roomMouseDownX = 0;
let roomMouseDownY = 0;
let startWidth = 0;
let startHeight = 0;
let startRadius = 0;
let resizeStartCenterX = 0;
let resizeStartCenterY = 0;
let startRotation = 0;
let endTranslateX = 0;
let endTranslateY = 0;
// Room-space pivot point for the in-progress rotate/resize drag (the table's own
// center at drag start) — unrelated to the Table type's centerX/centerY field.
let dragPivotX = 0;
let dragPivotY = 0;
let nextTableColor: ColorToken | undefined = undefined;
// Controls table movement and rotation-angle snapping — resizing always
// snaps/magnetizes regardless.
let snapTablesToGrid = true;
let chairGuestBallMode: "initials" | "fullName" = "fullName";
let selectedTables: {
  tableId: TableId;
  startCenterX: number;
  startCenterY: number;
  startRotation: number;
}[] = [];
let selectedGuests: { guestId: GuestId }[] = [];
// Told when the selection changes, when a table's element is redrawn from
// its data (updateTableDom), and when the side lists are rebuilt
// (updateAllGuestList, updateAllTablesInfo, updateRoomTabs) — so what is
// drawn for the others (presence.ts) follows. Seams, not calls: presence.ts
// loads last, and some of these run at load.
let selectionChangedListener: (() => void) | undefined;
let tableDomUpdatedListener: ((tableId: TableId) => void) | undefined;
let listsRenderedListener: (() => void) | undefined;
// Told when the room's scale is set (room.ts applyRoomScale) — with a scroll
// listener that is every way the view changes; presence.ts shares the view.
let viewportChangedListener: (() => void) | undefined;
let selectedGroupId: GroupId | undefined = undefined;
let guestRowOffsets: { top: number; height: number }[] = [];
let guestListTop = 0;
let newListIndex = 0;
// Guest list virtualization: only rows near the scrolled viewport of #allGuests are
// actually rendered, except while suspended (during a row drag), when the whole list
// is rendered so the existing drag math can measure/target every row by id.
let guestListVirtualizationSuspended = false;
let guestRowHeightCache: { [guestId: string]: number } = {};
let clipboard:
  | {
      table: Table;
      chairs: ChairSpot[];
    }[]
  | undefined = undefined;
