@happychef/algorithm 1.2.10 → 1.2.12

package/assignTables.js

@@ -1,398 +1,424 @@
-const { tryGroupTables } = require("./grouping");
-
-/**
- * server side
- * Parses a time string ("HH:MM") into minutes since midnight.
- * Returns NaN if the format is invalid.
- */
-function parseTime(timeStr) {
-    if (!timeStr || typeof timeStr !== 'string') return NaN;
-    const parts = timeStr.split(':');
-    if (parts.length !== 2) return NaN;
-    const hours = parseInt(parts[0], 10);
-    const minutes = parseInt(parts[1], 10);
-    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
-        return NaN;
-    }
-    return hours * 60 + minutes;
-}
-
-const shifts = {
-    breakfast: { start: '07:00', end: '11:00' },
-    lunch: { start: '11:00', end: '16:00' },
-    dinner: { start: '16:00', end: '23:00' },
-};
-
-/**
- * Determines the meal type ('breakfast', 'lunch', 'dinner') for a given time string ("HH:MM").
- * Returns null if the time doesn't fall into a defined shift.
- */
-function getMealTypeByTime(timeStr) {
-    const time = parseTime(timeStr);
-    if (isNaN(time)) return null;
-
-    for (const [mealType, shift] of Object.entries(shifts)) {
-        const start = parseTime(shift.start);
-        const end = parseTime(shift.end);
-        if (isNaN(start) || isNaN(end)) continue;
-
-        if (time >= start && time < end) {
-            return mealType;
-        }
-    }
-    return null;
-}
-
-/**
- * Checks if a temporary table is valid for a specific reservation date and time.
- * @param {Object} table - The table object with isTemporary, startDate, endDate, application properties.
- * @param {string} reservationDateStr - The date of the reservation ("YYYY-MM-DD").
- * @param {string} reservationTimeStr - The time of the reservation ("HH:MM").
- * @returns {boolean} True if the table is valid, false otherwise.
- */
-function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
-    if (!table.isTemporary) {
-        return true; // Not temporary, always valid (subject to other checks like availability)
-    }
-
-    // Check date range
-    if (!table.startDate || !table.endDate) {
-        return false; // Invalid temporary table definition
-    }
-    
-    // Basic date string comparison (YYYY-MM-DD format)
-    if (reservationDateStr < table.startDate || reservationDateStr > table.endDate) {
-        return false;
-    }
-
-    // Check application (meal type/shift)
-    const reservationMealType = getMealTypeByTime(reservationTimeStr);
-    if (!reservationMealType) {
-        return false; // Cannot determine meal type for the reservation
-    }
-    
-    if (table.application !== reservationMealType) {
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * computeRequiredSlots(timeString, durationMinutes, intervalMinutes)
- * Converts a reservation's start time and duration into discrete time slots.
- * e.g., timeString = "12:30", duration = 400 minutes, interval = 50 minutes
- */
-function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
-    // Validate time format
-    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
-    if (!timePattern.test(timeString)) {
-      throw new Error("Invalid time format. Expected 'HH:MM'.");
-    }
-  
-    const [hour, minute] = timeString.split(":").map(Number);
-    const startMinutes = hour * 60 + minute;
-    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
-    const slots = [];
-    for (let i = 0; i < slotCount; i++) {
-      slots.push(startMinutes + i * intervalMinutes);
-    }
-    return slots;
-}
-  
-/**
- * isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots)
- * Checks if the given tableNumber is free (no overlapping) for all requiredSlots.
- */
-function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
-    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
-    // If any slot from requiredSlots is in occupiedSlots, the table is not free
-    return !requiredSlots.some(slot => occupiedSlots.has(slot));
-}
-  
-/**
- * calculateDistance(tableA, tableB)
- * Euclidean distance between two tables (for multi-table distance minimization).
- */
-function calculateDistance(tableA, tableB) {
-    const dx = tableA.x - tableB.x;
-    const dy = tableA.y - tableB.y;
-    return Math.sqrt(dx * dx + dy * dy);
-}
-  
-function distanceSum(set) {
-  let sum = 0;
-  for (let i = 0; i < set.length; i++) {
-    for (let j = i + 1; j < set.length; j++) {
-      sum += calculateDistance(set[i], set[j]);
-    }
-  }
-  return sum;
-}
-
-function findMultiTableCombination(
-  tables,
-  guestsTotal,
-  startIndex,
-  currentSet,
-  best,
-  requiredSlots,
-  tableOccupiedSlots,
-  reservationDate,
-  reservationTime,
-  suffixMax // optional precomputed array
-) {
-  // Precompute suffix max-capacity once
-  if (!suffixMax) {
-    suffixMax = new Array(tables.length + 1).fill(0);
-    for (let i = tables.length - 1; i >= 0; i--) {
-      suffixMax[i] = suffixMax[i + 1] + tables[i].maxCapacity;
-    }
-  }
-
-  // Compute current set min/max sums
-  let curMin = 0, curMax = 0;
-  for (const t of currentSet) {
-    curMin += t.minCapacity;
-    curMax += t.maxCapacity;
-  }
-
-  // Prune: too many required seats already
-  if (curMin > guestsTotal) return;
-  // Prune: even with all remaining tables, can't reach guests
-  if (curMax + suffixMax[startIndex] < guestsTotal) return;
-
-  // Feasible set -> evaluate distance and update best
-  if (curMin <= guestsTotal && guestsTotal <= curMax) {
-    const d = distanceSum(currentSet);
-    if (d < best.minDistance) {
-      best.minDistance = d;
-      best.tables = [...currentSet];
-    }
-    // Continue searching; a tighter cluster may exist.
-  }
-
-  // Try adding more tables
-  for (let i = startIndex; i < tables.length; i++) {
-    const tbl = tables[i];
-
-    if (!isTemporaryTableValid(tbl, reservationDate, reservationTime)) continue;
-    if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) continue;
-
-    currentSet.push(tbl);
-    findMultiTableCombination(
-      tables,
-      guestsTotal,
-      i + 1,
-      currentSet,
-      best,
-      requiredSlots,
-      tableOccupiedSlots,
-      reservationDate,
-      reservationTime,
-      suffixMax
-    );
-    currentSet.pop();
-  }
-}
-
-  
-/**
- * assignTablesIfPossible
- * Attempts to assign tables to a reservation based on availability and constraints.
- * Modifies the reservation object by attaching 'tables' and 'tableIds' if successful.
- */
-async function assignTablesIfPossible({
-    db,
-    reservation,
-    enforceTableAvailability
-}) {
-    const restaurantId = reservation.restaurantId;
-    const date = reservation.date;
-    const time = reservation.time;
-    const guests = reservation.guests;
-  
-    // 1) First, fetch restaurant data (which contains the floors information)
-    const restaurantSettings = await db.collection('restaurants').findOne({ _id: restaurantId });
-    if (!restaurantSettings) {
-      if (enforceTableAvailability) {
-        throw new Error('Restaurant settings not found.');
-      } else {
-        return; // Non-enforcing: skip table assignment
-      }
-    }
-  
-    // 2) Get floors data directly from the restaurant document
-    const floorsData = restaurantSettings.floors;
-    if (!floorsData || !Array.isArray(floorsData) || floorsData.length === 0) {
-      if (enforceTableAvailability) {
-        throw new Error('No floors data found in restaurant document.');
-      } else {
-        return; // Non-enforcing: skip table assignment
-      }
-    }
-  
-    // 3) Collect all "Tafel" tables
-    let allTables = [];
-    floorsData.forEach(floor => {
-      if (floor.tables && Array.isArray(floor.tables)) {
-        floor.tables.forEach(tbl => {
-          if (tbl.objectType === "Tafel") {
-            allTables.push({
-              tableId: tbl.id,
-              tableNumber: parseInt(tbl.tableNumber.$numberInt || tbl.tableNumber),
-              minCapacity: parseInt(tbl.minCapacity.$numberInt || tbl.minCapacity),
-              maxCapacity: parseInt(tbl.maxCapacity.$numberInt || tbl.maxCapacity),
-              priority: parseInt(tbl.priority.$numberInt || tbl.priority),
-              x: parseInt(tbl.x.$numberInt || tbl.x),
-              y: parseInt(tbl.y.$numberInt || tbl.y),
-              isTemporary: tbl.isTemporary === true, // Added for temporary tables
-              startDate: tbl.startDate || null, // Added for temporary tables
-              endDate: tbl.endDate || null, // Added for temporary tables
-              application: tbl.application || null // Added for temporary tables
-            });
-          }
-        });
-      }
-    });
-  
-    // 4) If no tables found
-    if (!allTables.length) {
-      if (enforceTableAvailability) {
-        throw new Error('No tables found for this restaurant.');
-      } else {
-        return; // Non-enforcing: skip table assignment
-      }
-    }
-  
-    // 5) Sort the tables
-    allTables.sort((a, b) => {
-      if (a.maxCapacity !== b.maxCapacity) {
-        return a.maxCapacity - b.maxCapacity;
-      }
-      if (a.priority !== b.priority) {
-        return a.priority - b.priority;
-      }
-      return a.minCapacity - b.minCapacity;
-    });
-  
-    // 6) Get duration and interval settings
-    const duurReservatie = parseInt(
-      restaurantSettings["general-settings"]?.duurReservatie?.$numberInt || restaurantSettings["general-settings"]?.duurReservatie || 120
-    );
-    const intervalReservatie = parseInt(
-      restaurantSettings["general-settings"]?.intervalReservatie?.$numberInt || restaurantSettings["general-settings"]?.intervalReservatie || 30
-    );
-  
-    // 7) Compute the requiredSlots for this reservation
-    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-  
-    // 8) Get overlapping reservations (same date, same restaurant)
-    const overlappingReservations = await db.collection('reservations').find({
-      restaurantId: restaurantId,
-      date: date
-    }).toArray();
-  
-    // 9) Build tableOccupiedSlots map
-    let tableOccupiedSlots = {}; // { [tableNumber]: Set([...slots]) }
-    for (let r of overlappingReservations) {
-      // No need to skip the current reservation as it's not yet inserted
-  
-      // compute that reservation's time slots
-      const rDuration = duurReservatie; // assuming same duration
-      const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
-  
-      if (r.tables) {
-        for (let tn of r.tables) {
-          if (!tableOccupiedSlots[tn]) {
-            tableOccupiedSlots[tn] = new Set();
-          }
-          rSlots.forEach(slot => {
-            tableOccupiedSlots[tn].add(slot);
-          });
-        }
-      }
-    }
-      // ===== 9.5) Table Grouping Attempt (moved to grouping.js) =====
-    try {
-      const groupingResult = tryGroupTables({
-        restaurantSettings,
-        allTables,
-        guests,
-        date,
-        time,
-        requiredSlots,
-        tableOccupiedSlots,
-        isTemporaryTableValid,
-        isTableFreeForAllSlots,
-      });
-
-      if (groupingResult) {
-        reservation.tables = groupingResult.tables;
-        reservation.tableIds = groupingResult.tableIds;
-        reservation._viaGroup = groupingResult.viaGroup;
-        console.log(
-          `[Grouping] via '${reservation._viaGroup}' -> tables ${reservation.tables.join(",")}`
-        );
-        return; // grouping wins
-      }
-    } catch (err) {
-      // strict grouping throws; preserve original behavior
-      throw err;
-    }
-  // ===== end 9.5) Table Grouping Attempt =====
-
-    // 10) Single-Table Attempt
-    for (let t of allTables) {
-      // Check if temporary table is valid for this date/time
-      if (!isTemporaryTableValid(t, date, time)) {
-        continue; // Skip invalid temporary table
-      }
-      
-      if (
-        t.minCapacity <= guests &&
-        guests <= t.maxCapacity &&
-        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
-      ) {
-        // Assign this table to the reservation
-        reservation.tables = [t.tableNumber];
-        reservation.tableIds = [t.tableId];
-        console.log(`Reservation assigned to table: ${t.tableNumber}`);
-        return; // Assignment successful
-      }
-    }
-  
-    // 11) Multi-Table Attempt
-    let best = { minDistance: Infinity, tables: [] };
-  
-    findMultiTableCombination(
-      allTables,
-      guests,
-      0,
-      [],
-      best,
-      requiredSlots,
-      tableOccupiedSlots,
-      date,  // Pass date for temporary table validation
-      time   // Pass time for temporary table validation
-    );
-  
-    if (best.tables.length > 0) {
-      // Assign the best combination to the reservation
-      reservation.tables = best.tables.map(t => t.tableNumber);
-      reservation.tableIds = best.tables.map(t => t.tableId);
-      console.log(`Reservation assigned to tables: ${reservation.tables.join(', ')}`);
-      return; // Assignment successful
-    } else {
-      // If no valid table combo found, either fail (if enforce) or do nothing (if not enforce)
-      if (enforceTableAvailability) {
-        throw new Error('Unable to find enough tables for this reservation with enforcement on.');
-      } else {
-        console.log('No tables available, but non-enforcing mode => continuing without assignment.');
-      }
-    }
-}
-  
-module.exports = {
-    assignTablesIfPossible
-};
+const { tryGroupTables } = require("./grouping");
+
+/**
+ * server side
+ * Parses a time string ("HH:MM") into minutes since midnight.
+ * Returns NaN if the format is invalid.
+ */
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') return NaN;
+    const parts = timeStr.split(':');
+    if (parts.length !== 2) return NaN;
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return NaN;
+    }
+    return hours * 60 + minutes;
+}
+
+const shifts = {
+    breakfast: { start: '07:00', end: '11:00' },
+    lunch: { start: '11:00', end: '16:00' },
+    dinner: { start: '16:00', end: '23:00' },
+};
+
+/**
+ * Determines the meal type ('breakfast', 'lunch', 'dinner') for a given time string ("HH:MM").
+ * Returns null if the time doesn't fall into a defined shift.
+ */
+function getMealTypeByTime(timeStr) {
+    const time = parseTime(timeStr);
+    if (isNaN(time)) return null;
+
+    for (const [mealType, shift] of Object.entries(shifts)) {
+        const start = parseTime(shift.start);
+        const end = parseTime(shift.end);
+        if (isNaN(start) || isNaN(end)) continue;
+
+        if (time >= start && time < end) {
+            return mealType;
+        }
+    }
+    return null;
+}
+
+/**
+ * Checks if a temporary table is valid for a specific reservation date and time.
+ * @param {Object} table - The table object with isTemporary, startDate, endDate, application properties.
+ * @param {string} reservationDateStr - The date of the reservation ("YYYY-MM-DD").
+ * @param {string} reservationTimeStr - The time of the reservation ("HH:MM").
+ * @returns {boolean} True if the table is valid, false otherwise.
+ */
+function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
+    if (!table.isTemporary) {
+        return true; // Not temporary, always valid (subject to other checks like availability)
+    }
+
+    // Check date range
+    if (!table.startDate || !table.endDate) {
+        return false; // Invalid temporary table definition
+    }
+
+    // Basic date string comparison (YYYY-MM-DD format)
+    if (reservationDateStr < table.startDate || reservationDateStr > table.endDate) {
+        return false;
+    }
+
+    // Check application (meal type/shift)
+    const reservationMealType = getMealTypeByTime(reservationTimeStr);
+    if (!reservationMealType) {
+        return false; // Cannot determine meal type for the reservation
+    }
+
+    if (table.application !== reservationMealType) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * computeRequiredSlots(timeString, durationMinutes, intervalMinutes)
+ * Converts a reservation's start time and duration into discrete time slots.
+ * e.g., timeString = "12:30", duration = 400 minutes, interval = 50 minutes
+ */
+function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
+    // Validate time format
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (!timePattern.test(timeString)) {
+      throw new Error("Invalid time format. Expected 'HH:MM'.");
+    }
+
+    const [hour, minute] = timeString.split(":").map(Number);
+    const startMinutes = hour * 60 + minute;
+    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
+    const slots = [];
+    for (let i = 0; i < slotCount; i++) {
+      slots.push(startMinutes + i * intervalMinutes);
+    }
+    return slots;
+}
+
+/**
+ * isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots)
+ * Checks if the given tableNumber is free (no overlapping) for all requiredSlots.
+ */
+function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
+    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
+    // If any slot from requiredSlots is in occupiedSlots, the table is not free
+    return !requiredSlots.some(slot => occupiedSlots.has(slot));
+}
+
+/**
+ * calculateDistance(tableA, tableB)
+ * Euclidean distance between two tables (for multi-table distance minimization).
+ */
+function calculateDistance(tableA, tableB) {
+    const dx = tableA.x - tableB.x;
+    const dy = tableA.y - tableB.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+function distanceSum(set) {
+  let sum = 0;
+  for (let i = 0; i < set.length; i++) {
+    for (let j = i + 1; j < set.length; j++) {
+      sum += calculateDistance(set[i], set[j]);
+    }
+  }
+  return sum;
+}
+
+function findMultiTableCombination(
+  tables,
+  guestsTotal,
+  startIndex,
+  currentSet,
+  best,
+  requiredSlots,
+  tableOccupiedSlots,
+  reservationDate,
+  reservationTime,
+  suffixMax // optional precomputed array
+) {
+  // Precompute suffix max-capacity once
+  if (!suffixMax) {
+    suffixMax = new Array(tables.length + 1).fill(0);
+    for (let i = tables.length - 1; i >= 0; i--) {
+      suffixMax[i] = suffixMax[i + 1] + tables[i].maxCapacity;
+    }
+  }
+
+  // Compute current set min/max sums
+  let curMin = 0, curMax = 0;
+  for (const t of currentSet) {
+    curMin += t.minCapacity;
+    curMax += t.maxCapacity;
+  }
+
+  // Prune: too many required seats already
+  if (curMin > guestsTotal) return;
+  // Prune: even with all remaining tables, can't reach guests
+  if (curMax + suffixMax[startIndex] < guestsTotal) return;
+
+  // Feasible set -> evaluate distance and update best
+  if (curMin <= guestsTotal && guestsTotal <= curMax) {
+    const d = distanceSum(currentSet);
+    if (d < best.minDistance) {
+      best.minDistance = d;
+      best.tables = [...currentSet];
+    }
+    // Continue searching; a tighter cluster may exist.
+  }
+
+  // Try adding more tables
+  for (let i = startIndex; i < tables.length; i++) {
+    const tbl = tables[i];
+
+    if (!isTemporaryTableValid(tbl, reservationDate, reservationTime)) continue;
+    if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) continue;
+
+    currentSet.push(tbl);
+    findMultiTableCombination(
+      tables,
+      guestsTotal,
+      i + 1,
+      currentSet,
+      best,
+      requiredSlots,
+      tableOccupiedSlots,
+      reservationDate,
+      reservationTime,
+      suffixMax
+    );
+    currentSet.pop();
+  }
+}
+
+/**
+ * Gets the floor ID linked to a seat place from seatAreaFloorLinks.
+ * @param {Object} restaurantSettings - The restaurant settings object.
+ * @param {string} seatPlace - The seat place identifier.
+ * @returns {string|null} The floor ID or null if not found.
+ */
+function getFloorIdForSeatPlace(restaurantSettings, seatPlace) {
+    if (!seatPlace || !restaurantSettings) return null;
+    const seatAreaFloorLinks = restaurantSettings["general-settings"]?.seatAreaFloorLinks;
+    if (!seatAreaFloorLinks || typeof seatAreaFloorLinks !== 'object') return null;
+    return seatAreaFloorLinks[seatPlace] || null;
+}
+
+
+/**
+ * assignTablesIfPossible
+ * Attempts to assign tables to a reservation based on availability and constraints.
+ * Modifies the reservation object by attaching 'tables' and 'tableIds' if successful.
+ */
+async function assignTablesIfPossible({
+    db,
+    reservation,
+    enforceTableAvailability
+}) {
+    const restaurantId = reservation.restaurantId;
+    const date = reservation.date;
+    const time = reservation.time;
+    const guests = reservation.guests;
+    const zitplaats = reservation.zitplaats;
+
+    // 1) First, fetch restaurant data (which contains the floors information)
+    const restaurantSettings = await db.collection('restaurants').findOne({ _id: restaurantId });
+    if (!restaurantSettings) {
+      if (enforceTableAvailability) {
+        throw new Error('Restaurant settings not found.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+
+    // 2) Get floors data directly from the restaurant document
+    let floorsData = restaurantSettings.floors;
+    if (!floorsData || !Array.isArray(floorsData) || floorsData.length === 0) {
+      if (enforceTableAvailability) {
+        throw new Error('No floors data found in restaurant document.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+
+    // 2.5) If zitplaats is specified and has a floor link, try that floor first
+    const linkedFloorId = getFloorIdForSeatPlace(restaurantSettings, zitplaats);
+    let preferredFloorOnly = null;
+    if (linkedFloorId) {
+      const linkedFloor = floorsData.find(f => f.id === linkedFloorId);
+      if (linkedFloor) {
+        preferredFloorOnly = [linkedFloor];
+        console.log(`[Zitplaats] Will try floor '${linkedFloorId}' first for zitplaats '${zitplaats}'`);
+      }
+    }
+
+    // 3) Helper to collect tables from floors
+    function collectTablesFromFloors(floors) {
+      const tables = [];
+      floors.forEach(floor => {
+        if (floor.tables && Array.isArray(floor.tables)) {
+          floor.tables.forEach(tbl => {
+            if (tbl.objectType === "Tafel") {
+              tables.push({
+                tableId: tbl.id,
+                tableNumber: parseInt(tbl.tableNumber.$numberInt || tbl.tableNumber),
+                minCapacity: parseInt(tbl.minCapacity.$numberInt || tbl.minCapacity),
+                maxCapacity: parseInt(tbl.maxCapacity.$numberInt || tbl.maxCapacity),
+                priority: parseInt(tbl.priority.$numberInt || tbl.priority),
+                x: parseInt(tbl.x.$numberInt || tbl.x),
+                y: parseInt(tbl.y.$numberInt || tbl.y),
+                isTemporary: tbl.isTemporary === true,
+                startDate: tbl.startDate || null,
+                endDate: tbl.endDate || null,
+                application: tbl.application || null
+              });
+            }
+          });
+        }
+      });
+      return tables;
+    }
+
+    // Collect all tables from all floors
+    let allTables = collectTablesFromFloors(floorsData);
+
+    // Collect tables from preferred floor only (if specified)
+    let preferredFloorTables = preferredFloorOnly ? collectTablesFromFloors(preferredFloorOnly) : null;
+
+    // 4) If no tables found
+    if (!allTables.length) {
+      if (enforceTableAvailability) {
+        throw new Error('No tables found for this restaurant.');
+      } else {
+        return; // Non-enforcing: skip table assignment
+      }
+    }
+
+    // 5) Get duration and interval settings
+    const duurReservatie = parseInt(
+      restaurantSettings["general-settings"]?.duurReservatie?.$numberInt || restaurantSettings["general-settings"]?.duurReservatie || 120
+    );
+    const intervalReservatie = parseInt(
+      restaurantSettings["general-settings"]?.intervalReservatie?.$numberInt || restaurantSettings["general-settings"]?.intervalReservatie || 30
+    );
+
+    // 7) Compute the requiredSlots for this reservation
+    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+
+    // 8) Get overlapping reservations (same date, same restaurant)
+    const overlappingReservations = await db.collection('reservations').find({
+      restaurantId: restaurantId,
+      date: date
+    }).toArray();
+
+    // 9) Build tableOccupiedSlots map
+    let tableOccupiedSlots = {}; // { [tableNumber]: Set([...slots]) }
+    for (let r of overlappingReservations) {
+      // No need to skip the current reservation as it's not yet inserted
+
+      // compute that reservation's time slots
+      const rDuration = duurReservatie; // assuming same duration
+      const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
+
+      if (r.tables) {
+        for (let tn of r.tables) {
+          if (!tableOccupiedSlots[tn]) {
+            tableOccupiedSlots[tn] = new Set();
+          }
+          rSlots.forEach(slot => {
+            tableOccupiedSlots[tn].add(slot);
+          });
+        }
+      }
+    }
+
+    // 10) Helper function to try table assignment from a given set of tables
+    function tryAssignTables(tables, label) {
+      // Sort tables
+      const sortedTables = [...tables].sort((a, b) => {
+        if (a.maxCapacity !== b.maxCapacity) return a.maxCapacity - b.maxCapacity;
+        if (a.priority !== b.priority) return a.priority - b.priority;
+        return a.minCapacity - b.minCapacity;
+      });
+
+      // Try grouping first
+      try {
+        const groupingResult = tryGroupTables({
+          restaurantSettings,
+          allTables: sortedTables,
+          guests,
+          date,
+          time,
+          requiredSlots,
+          tableOccupiedSlots,
+          isTemporaryTableValid,
+          isTableFreeForAllSlots,
+        });
+
+        if (groupingResult) {
+          reservation.tables = groupingResult.tables;
+          reservation.tableIds = groupingResult.tableIds;
+          reservation._viaGroup = groupingResult.viaGroup;
+          console.log(`[${label}] [Grouping] via '${reservation._viaGroup}' -> tables ${reservation.tables.join(",")}`);
+          return true;
+        }
+      } catch (err) {
+        throw err;
+      }
+
+      // Try single-table assignment
+      for (let t of sortedTables) {
+        if (!isTemporaryTableValid(t, date, time)) continue;
+        if (t.minCapacity <= guests && guests <= t.maxCapacity &&
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) {
+          reservation.tables = [t.tableNumber];
+          reservation.tableIds = [t.tableId];
+          console.log(`[${label}] Assigned to table: ${t.tableNumber}`);
+          return true;
+        }
+      }
+
+      // Try multi-table combination
+      let best = { minDistance: Infinity, tables: [] };
+      findMultiTableCombination(sortedTables, guests, 0, [], best, requiredSlots, tableOccupiedSlots, date, time);
+
+      if (best.tables.length > 0) {
+        reservation.tables = best.tables.map(t => t.tableNumber);
+        reservation.tableIds = best.tables.map(t => t.tableId);
+        console.log(`[${label}] Assigned to tables: ${reservation.tables.join(', ')}`);
+        return true;
+      }
+
+      return false;
+    }
+
+    // 11) Try preferred floor first (if specified), then fall back to all floors
+    if (preferredFloorTables && preferredFloorTables.length > 0) {
+      console.log(`[Zitplaats] Trying preferred floor first (${preferredFloorTables.length} tables)`);
+      if (tryAssignTables(preferredFloorTables, 'PreferredFloor')) {
+        return; // Success on preferred floor
+      }
+      console.log(`[Zitplaats] No availability on preferred floor, falling back to all floors`);
+    }
+
+    // 12) Try all floors
+    if (tryAssignTables(allTables, 'AllFloors')) {
+      return; // Success
+    }
+
+    // 13) No valid table combo found
+    if (enforceTableAvailability) {
+      throw new Error('Unable to find enough tables for this reservation with enforcement on.');
+    } else {
+      console.log('No tables available, but non-enforcing mode => continuing without assignment.');
+    }
+}
+
+module.exports = {
+    assignTablesIfPossible
+};