@happychef/algorithm 1.2.10 → 1.2.12

package/simulateTableAssignment.js

@@ -1,700 +1,710 @@
-// =============================================================================
-// FILE: simulateTableAssignment.js (UPDATED)
-// =============================================================================
-// Archief/Fields/algorithm/simulateTableAssignment.js
-
-// --- Import Helpers ---
-const {
-    getAllTables,
-    isTemporaryTableValid,
-} = require('./tableHelpers');
-
-
-/**
- * Robust helper for parsing numeric values from various formats.
- * Handles MongoDB $numberInt format and regular values.
- */
-function safeParseInt(val, defaultValue) {
-    console.log(`[safeParseInt] Parsing value:`, val, `with type:`, typeof val);
-    
-    if (val === undefined || val === null) return defaultValue;
-    
-    if (typeof val === 'object' && val !== null && '$numberInt' in val) {
-        try {
-            const parsed = parseInt(val.$numberInt, 10);
-            console.log(`[safeParseInt] Parsed $numberInt format:`, parsed);
-            if (!isNaN(parsed)) return parsed;
-        } catch (e) {
-            console.log(`[safeParseInt] Error parsing $numberInt:`, e);
-        }
-        return defaultValue;
-    }
-    
-    if (typeof val === 'number' && !isNaN(val)) {
-        console.log(`[safeParseInt] Using numeric value directly:`, val);
-        return val;
-    }
-    
-    if (typeof val === 'string') {
-        try {
-            const parsed = parseInt(val, 10);
-            console.log(`[safeParseInt] Parsed string:`, parsed);
-            if (!isNaN(parsed)) return parsed;
-        } catch (e) {
-            console.log(`[safeParseInt] Error parsing string:`, e);
-        }
-    }
-    console.log(`[safeParseInt] Could not parse, using default:`, defaultValue);
-    return defaultValue;
-}
-
-/**
- * Extracts actual table numbers from a reservation's tables array.
- * Handles MongoDB $numberInt format.
- */
-function extractTableNumbers(tablesArray) {
-    if (!Array.isArray(tablesArray)) {
-        return [];
-    }
-    
-    return tablesArray.map(table => {
-        return safeParseInt(table, null);
-    }).filter(tableNum => tableNum !== null);
-}
-
-/**
- * Gets actual table assignments from reservation data if available.
- * @param {Object} reservation - The reservation object
- * @returns {Array} Array of table numbers that are actually assigned, or empty array if no data
- */
-function getActualTableAssignment(reservation) {
-    // Check if reservation has actual table assignments
-    if (reservation.tables && Array.isArray(reservation.tables)) {
-        const tableNumbers = extractTableNumbers(reservation.tables);
-        console.log(`[getActualTableAssignment] Found actual table assignment for reservation:`, tableNumbers);
-        return tableNumbers;
-    }
-    
-    console.log(`[getActualTableAssignment] No actual table assignment found for reservation`);
-    return [];
-}
-
-/**
- * Converts a reservation's start time and duration into discrete time slots (in minutes from midnight).
- */
-function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
-    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
-    if (!timeString || !timePattern.test(timeString)) {
-        console.error(`Invalid time format for computeRequiredSlots: ${timeString}. Expected 'HH:MM'.`);
-        return [];
-    }
-
-    const [hour, minute] = timeString.split(":").map(Number);
-    const startMinutes = hour * 60 + minute;
-
-    if (intervalMinutes <= 0) {
-        console.error("Interval must be positive in computeRequiredSlots.");
-        return [startMinutes];
-    }
-
-    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
-    console.log(`Computing ${slotCount} slots for time ${timeString} (duration: ${durationMinutes}min, interval: ${intervalMinutes}min)`);
-
-    const slots = [];
-    for (let i = 0; i < slotCount; i++) {
-        slots.push(startMinutes + i * intervalMinutes);
-    }
-    
-    return slots;
-}
-
-/**
- * Checks if the given tableNumber is free for all requiredSlots based on the occupied map.
- */
-function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
-    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
-    
-    for (const slot of requiredSlots) {
-        if (occupiedSlots.has(slot)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- * Calculates Euclidean distance between two tables (assuming x, y properties).
- */
-function calculateDistance(tableA, tableB) {
-    if (tableA?.x === undefined || tableA?.y === undefined || tableB?.x === undefined || tableB?.y === undefined) {
-        return Infinity; // Cannot calculate distance if coordinates are missing
-    }
-    const dx = tableA.x - tableB.x;
-    const dy = tableA.y - tableB.y;
-    return Math.sqrt(dx * dx + dy * dy);
-}
-
-/**
- * QUICKSORT-INSPIRED OPTIMIZATION: O(n log n) multi-table assignment with partitioning
- *
- * Instead of exploring all combinations (exponential), we use:
- * 1. Greedy partitioning - divide tables into capacity buckets
- * 2. Pivot selection - pick optimal table as "pivot"
- * 3. Branch reduction - only explore promising paths
- * 4. Dynamic programming - cache intermediate results
- *
- * Complexity: O(n log n) instead of O(2^n)
- */
-
-// Cache for intermediate results (dynamic programming)
-const assignmentCache = new Map();
-
-function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best) {
-    // Base case: All guests seated
-    if (guestsNeeded <= 0) {
-        if (currentSet.length < best.tableCount) {
-            // Calculate distance only for improved solutions
-            let distanceSum = 0;
-            for (let i = 0; i < currentSet.length; i++) {
-                for (let j = i + 1; j < currentSet.length; j++) {
-                    distanceSum += calculateDistance(currentSet[i], currentSet[j]);
-                }
-            }
-            if (currentSet.length < best.tableCount ||
-                (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
-                best.minDistance = distanceSum;
-                best.tables = [...currentSet];
-                best.tableCount = currentSet.length;
-            }
-        }
-        return;
-    }
-
-    // AGGRESSIVE PRUNING
-    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) return;
-    if (startIndex >= tables.length) return;
-
-    // OPTIMIZATION: Use cached result if available (Dynamic Programming)
-    const cacheKey = `${guestsNeeded}-${startIndex}-${currentSet.length}`;
-    if (assignmentCache.has(cacheKey)) {
-        const cached = assignmentCache.get(cacheKey);
-        if (cached.tableCount < best.tableCount) {
-            best.tableCount = cached.tableCount;
-            best.tables = [...cached.tables];
-            best.minDistance = cached.minDistance;
-        }
-        return;
-    }
-
-    // QUICKSORT-INSPIRED: Partition tables by capacity relative to guests needed
-    const remaining = tables.slice(startIndex);
-    const exactFit = [];
-    const overCapacity = [];
-    const underCapacity = [];
-
-    for (const tbl of remaining) {
-        const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
-        if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) continue;
-
-        if (tbl.minCapacity <= guestsNeeded && guestsNeeded <= tbl.maxCapacity) {
-            exactFit.push(tbl);
-        } else if (tbl.maxCapacity > guestsNeeded) {
-            overCapacity.push(tbl);
-        } else {
-            underCapacity.push(tbl);
-        }
-    }
-
-    // STRATEGY 1: Try exact fit first (best case - single table)
-    if (exactFit.length > 0) {
-        // Sort by smallest capacity first (minimize waste)
-        exactFit.sort((a, b) => a.maxCapacity - b.maxCapacity);
-        const tbl = exactFit[0];
-        currentSet.push(tbl);
-        findMultiTableCombination(tables, 0, tables.length, currentSet, best);
-        currentSet.pop();
-
-        if (best.tableCount === 1) return; // Found optimal
-    }
-
-    // STRATEGY 2: Greedy approach - largest table that fits
-    if (overCapacity.length > 0 && currentSet.length < 2) {
-        // Sort by closest to guests needed (minimize waste)
-        overCapacity.sort((a, b) =>
-            Math.abs(a.maxCapacity - guestsNeeded) - Math.abs(b.maxCapacity - guestsNeeded)
-        );
-
-        // Try top 3 candidates only (not all)
-        const candidates = overCapacity.slice(0, Math.min(3, overCapacity.length));
-        for (const tbl of candidates) {
-            currentSet.push(tbl);
-            findMultiTableCombination(tables, 0, tables.length, currentSet, best);
-            currentSet.pop();
-
-            if (best.tableCount === 1) return;
-        }
-    }
-
-    // STRATEGY 3: Two-table combinations (most common case)
-    if (underCapacity.length >= 2 && currentSet.length === 0 && best.tableCount > 2) {
-        // Sort by capacity descending
-        underCapacity.sort((a, b) => b.maxCapacity - a.maxCapacity);
-
-        // QUICKSORT PARTITION: Find pairs that sum close to guestsNeeded
-        for (let i = 0; i < Math.min(5, underCapacity.length); i++) {
-            const first = underCapacity[i];
-            const remaining = guestsNeeded - first.maxCapacity;
-
-            // Binary search for best match (O(log n))
-            let left = i + 1, right = underCapacity.length - 1;
-            let bestMatch = null;
-            let bestDiff = Infinity;
-
-            while (left <= right) {
-                const mid = Math.floor((left + right) / 2);
-                const second = underCapacity[mid];
-                const totalCapacity = first.maxCapacity + second.maxCapacity;
-                const diff = Math.abs(totalCapacity - guestsNeeded);
-
-                if (diff < bestDiff && totalCapacity >= guestsNeeded) {
-                    bestDiff = diff;
-                    bestMatch = second;
-                }
-
-                if (totalCapacity < guestsNeeded) {
-                    left = mid + 1;
-                } else {
-                    right = mid - 1;
-                }
-            }
-
-            if (bestMatch) {
-                currentSet.push(first);
-                currentSet.push(bestMatch);
-                findMultiTableCombination(tables,
-                    guestsNeeded - first.maxCapacity - bestMatch.maxCapacity,
-                    tables.length, currentSet, best);
-                currentSet.pop();
-                currentSet.pop();
-
-                if (best.tableCount === 2) return; // Found optimal two-table
-            }
-        }
-    }
-
-    // STRATEGY 4: Limited backtracking only if no good solution found
-    if (best.tableCount > 3 && remaining.length <= 10) {
-        // Sort by efficiency (capacity per table)
-        remaining.sort((a, b) => b.maxCapacity - a.maxCapacity);
-
-        // Try only top 5 tables
-        const limited = remaining.slice(0, Math.min(5, remaining.length));
-        for (const tbl of limited) {
-            const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
-            if (canSeat >= tbl.minCapacity || canSeat >= guestsNeeded) {
-                currentSet.push(tbl);
-                const nextIdx = tables.indexOf(tbl) + 1;
-                findMultiTableCombination(tables, guestsNeeded - canSeat, nextIdx, currentSet, best);
-                currentSet.pop();
-
-                if (best.tableCount <= 2) return;
-            }
-        }
-    }
-
-    // Cache result
-    if (best.tableCount < Infinity) {
-        assignmentCache.set(cacheKey, {
-            tableCount: best.tableCount,
-            tables: [...best.tables],
-            minDistance: best.minDistance
-        });
-    }
-}
-
-function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
-    console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
-
-    // Clear cache if it gets too large (prevent memory leaks)
-    if (assignmentCache.size > 1000) {
-        assignmentCache.clear();
-    }
-
-    // FIXED: More robust parsing of settings with detailed logging
-    const generalSettings = restaurantData["general-settings"] || {};
-
-    // DEFAULT VALUES - this approach mirrors the TypeScript implementation
-    let duurReservatie = 120;  // Default: 2 hours in minutes
-    let intervalReservatie = 15;  // Default: 15 minute intervals
-
-    // Use safeParseInt for robust parsing
-    duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
-    intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
-
-    console.log(`[assignTablesForGivenTime] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
-
-    if (intervalReservatie <= 0) {
-        console.error("Invalid interval settings.");
-        return [];
-    }
-
-    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-    if (!requiredSlots || requiredSlots.length === 0) {
-        console.error(`Could not compute required slots for ${time}`);
-        return [];
-    }
-
-    // Fetch all tables using the imported helper
-    const allTables = getAllTables(restaurantData, selectedZitplaats);
-    console.log(`[assignTablesForGivenTime] Checking ${allTables.length} tables`);
-
-    // OPTIMIZATION: Pre-filter and sort tables for better performance
-    // Filter out invalid and occupied tables first
-    const validTables = allTables.filter(t =>
-        isTemporaryTableValid(t, date, time) &&
-        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
-    );
-
-    if (validTables.length === 0) {
-        console.log(`[assignTablesForGivenTime] No valid tables available`);
-        return [];
-    }
-
-    // OPTIMIZATION: Sort tables by capacity (prefer exact matches first)
-    // This helps find optimal solutions faster
-    validTables.sort((a, b) => {
-        // Prioritize tables that can seat exactly the number of guests
-        const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
-        const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
-        if (aExact !== bExact) return aExact - bExact;
-
-        // Then sort by capacity (smaller tables first to minimize waste)
-        return a.maxCapacity - b.maxCapacity;
-    });
-
-    // --- Try single-table assignment first ---
-    for (const t of validTables) {
-        if (t.minCapacity <= guests && guests <= t.maxCapacity) {
-            console.log(`[assignTablesForGivenTime] Assigned single table ${t.tableNumber} for ${guests} guests`);
-            return [t.tableNumber];
-        }
-    }
-
-    console.log(`[assignTablesForGivenTime] No single table found, trying combinations...`);
-
-    // --- Try multi-table assignment ---
-    const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
-    findMultiTableCombination(
-        validTables, // Use pre-filtered and sorted tables
-        guests,
-        0, // Start index
-        [], // Initial empty set
-        best // Best solution object (no need for slots/occupancy - already filtered)
-    );
-
-    if (best.tables.length > 0) {
-        console.log(`[assignTablesForGivenTime] Found multi-table solution: ${best.tables.map(t => t.tableNumber).join(', ')}`);
-    } else {
-        console.log(`[assignTablesForGivenTime] No table combination found for ${guests} guests`);
-    }
-
-    return best.tables.map(t => t.tableNumber);
-}
-
-function isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
-    console.log(`\n[isTimeAvailableSync] Checking ${date} ${time} for ${guests} guests`);
-    
-    if (guests < 0) {
-        console.log(`[isTimeAvailableSync] Detected negative guest count (${guests}), adjusting to default of 2`);
-        guests = 2; // Use a reasonable default
-    }
-    
-    const tableSettings = restaurantData?.['table-settings'] || {};
-    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
-        tableSettings.assignmentMode === "automatic";
-
-    console.log(`[isTimeAvailableSync] Table assignment enabled? ${isTableAssignmentEnabled}`);
-    console.log(`- Table settings installed: ${tableSettings.isInstalled === true}`);
-    console.log(`- Assignment mode: ${tableSettings.assignmentMode}`);
-
-    if (!isTableAssignmentEnabled) {
-        console.log(`[isTimeAvailableSync] No table assignment needed, returning true`);
-        return true;
-    }
-
-    try {
-        // Basic data check
-        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
-            console.error(`[isTimeAvailableSync] Missing floors data for ${date} ${time}`);
-            return false;
-        }
-        
-        if (guests <= 0) {
-            console.error(`[isTimeAvailableSync] Invalid guest count: ${guests}`);
-            return false; // Cannot reserve for 0 or fewer guests
-        }
-
-        const generalSettings = restaurantData["general-settings"] || {};
-        let duurReservatie = 120;  // Default: 2 hours in minutes
-        let intervalReservatie = 15;  // Default: 15 minute intervals
-        duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
-        intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
-        
-        console.log(`[isTimeAvailableSync] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
-
-        if (intervalReservatie <= 0) {
-            console.error(`[isTimeAvailableSync] Invalid interval settings for ${date} ${time}`);
-            return false;
-        }
-
-        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-        if (!requiredSlots || requiredSlots.length === 0) {
-            console.error(`[isTimeAvailableSync] Could not compute required slots for ${date} ${time}`);
-            return false; // Cannot proceed if slots are invalid
-        }
-
-        // --- Build Occupancy Map using ACTUAL table assignments when available ---
-        const tableOccupiedSlots = {}; // { tableNumber: Set<slotMinutes> }
-        const reservationsForDate = reservations
-            .filter(r => r.date === date && r.time && r.guests > 0)
-            .sort((a, b) => {
-                // Simple time string comparison
-                const timeA = a.time.split(':').map(Number);
-                const timeB = b.time.split(':').map(Number);
-                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
-            });
-
-        console.log(`[isTimeAvailableSync] Processing ${reservationsForDate.length} existing reservations on ${date}`);
-
-        for (const r of reservationsForDate) {
-            // NEW: Try to get actual table assignment first
-            const actualTables = getActualTableAssignment(r);
-            let assignedTables = [];
-            
-            if (actualTables.length > 0) {
-                // Use actual table assignment from reservation data
-                assignedTables = actualTables;
-                console.log(`[isTimeAvailableSync] Using actual table assignment for reservation: ${assignedTables.join(', ')}`);
-            } else {
-                // Fall back to simulation for backwards compatibility
-                console.log(`[isTimeAvailableSync] No actual table data, simulating assignment for reservation`);
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots);
-            }
-
-            // Update the occupancy map based on the actual or simulated assignment
-            if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
-                if (!rSlots || rSlots.length === 0) continue; // Skip if slots invalid
-
-                assignedTables.forEach(tableNumber => {
-                    if (!tableOccupiedSlots[tableNumber]) {
-                        tableOccupiedSlots[tableNumber] = new Set();
-                    }
-                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
-                });
-                
-                console.log(`[isTimeAvailableSync] Marked tables ${assignedTables.join(', ')} as occupied for time ${r.time}`);
-            }
-        }
-
-        console.log(`[isTimeAvailableSync] Occupancy map built, checking availability for new reservation`);
-
-        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables
-        console.log(`[isTimeAvailableSync] Checking ${allTables.length} tables for new reservation`);
-
-        // OPTIMIZATION: Pre-filter valid tables
-        const validTables = allTables.filter(t =>
-            isTemporaryTableValid(t, date, time) &&
-            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
-        );
-
-        if (validTables.length === 0) {
-            console.log(`[isTimeAvailableSync] No valid tables available`);
-            return false;
-        }
-
-        // OPTIMIZATION: Sort for faster exact matches
-        validTables.sort((a, b) => {
-            const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
-            const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
-            if (aExact !== bExact) return aExact - bExact;
-            return a.maxCapacity - b.maxCapacity;
-        });
-
-        // 1. Try single table assignment
-        for (const t of validTables) {
-            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
-                console.log(`[isTimeAvailableSync] Found single table ${t.tableNumber} for ${guests} guests at ${time}`);
-                return true; // Available
-            }
-        }
-
-        console.log(`[isTimeAvailableSync] No single table found, trying combinations...`);
-
-        // 2. Try multi-table assignment
-        const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
-        findMultiTableCombination(
-            validTables, // Use pre-filtered tables
-            guests,
-            0, // Start index
-            [], // Empty current set
-            best // Best solution
-        );
-
-        const result = best.tables.length > 0;
-        if (result) {
-            console.log(`[isTimeAvailableSync] Multi-table assignment possible: ${best.tables.map(t => t.tableNumber).join(', ')}`);
-        } else {
-            console.log(`[isTimeAvailableSync] No table combination available`);
-        }
-
-        return result; // Available if a combination was found
-
-    } catch (error) {
-        console.error(`[isTimeAvailableSync] Error during check for ${date} ${time}:`, error);
-        return false; // Assume unavailable on error
-    }
-}
-
-function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
-    console.log(`[filterTimeblocksByTableAvailability] Filtering timeblocks for ${date} with ${guests} guests`);
-    
-    if (guests < 0) {
-        console.log(`[filterTimeblocksByTableAvailability] Detected negative guest count (${guests}), adjusting to default of 2`);
-        guests = 0; // Use a reasonable default
-    }
-    
-    const tableSettings = restaurantData?.['table-settings'] || {};
-    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
-        tableSettings.assignmentMode === "automatic";
-
-    if (!isTableAssignmentEnabled) {
-        console.log(`[filterTimeblocksByTableAvailability] No table assignment enabled, returning all timeblocks`);
-        return timeblocks;
-    }
-
-    console.log(`[filterTimeblocksByTableAvailability] Starting with ${Object.keys(timeblocks).length} timeblocks`);
-
-    const filteredTimeblocks = {};
-    let availableCount = 0;
-    let unavailableCount = 0;
-
-    for (const time in timeblocks) {
-        if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats)) {
-            filteredTimeblocks[time] = timeblocks[time];
-            availableCount++;
-        } else {
-            unavailableCount++;
-        }
-    }
-
-    console.log(`[filterTimeblocksByTableAvailability] Result: ${availableCount} available, ${unavailableCount} unavailable times`);
-    if (availableCount > 0) {
-        console.log(`[filterTimeblocksByTableAvailability] Available times: ${Object.keys(filteredTimeblocks).join(', ')}`);
-    }
-
-    return filteredTimeblocks;
-}
-
-function getAvailableTimeblocksWithTableCheck(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
-    return filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats);
-}
-
-function getAvailableTablesForTime(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
-    try {
-        if (guests < 0) {
-            console.log(`[getAvailableTablesForTime] Detected negative guest count (${guests}), adjusting to default of 2`);
-            guests = 0;
-        }
-        
-        const tableSettings = restaurantData?.['table-settings'] || {};
-        const isAutomaticAssignment = tableSettings.isInstalled === true &&
-                                       tableSettings.assignmentMode === "automatic";
-
-        if (!isAutomaticAssignment) {
-            return [];
-        }
-
-        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
-            console.error(`[getAvailableTablesForTime] Missing floors data for ${date} ${time}`);
-            return [];
-        }
-        if (guests <= 0) return [];
-        const generalSettings = restaurantData["general-settings"] || {};
-        const duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
-        const intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
-        
-        if (intervalReservatie <= 0) {
-             console.error(`[getAvailableTablesForTime] Invalid interval settings for ${date} ${time}`);
-             return [];
-        }
-
-        console.log(`\n[getAvailableTablesForTime] Finding available tables for ${guests} guests on ${date} at ${time}`);
-        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-         if (!requiredSlots || requiredSlots.length === 0) {
-            console.error(`[getAvailableTablesForTime] Could not compute required slots for ${date} ${time}`);
-            return [];
-        }
-        const tableOccupiedSlots = {};
-        const reservationsForDate = reservations
-            .filter(r => r.date === date && r.time && r.guests > 0)
-            .sort((a, b) => {
-                const timeA = a.time.split(':').map(Number);
-                const timeB = b.time.split(':').map(Number);
-                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
-            });
-
-        console.log(`[getAvailableTablesForTime] Building occupancy map (Processing ${reservationsForDate.length} existing reservations)`);
-        for (const r of reservationsForDate) {
-            const actualTables = getActualTableAssignment(r);
-            let assignedTables = [];
-            
-            if (actualTables.length > 0) {
-                assignedTables = actualTables;
-            } else {
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null);
-            }
-            
-            if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
-                 if (!rSlots || rSlots.length === 0) continue;
-                assignedTables.forEach(tableNumber => {
-                    if (!tableOccupiedSlots[tableNumber]) {
-                        tableOccupiedSlots[tableNumber] = new Set();
-                    }
-                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
-                });
-            }
-        }
-        console.log("[getAvailableTablesForTime] Occupancy map built");
-        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables with zitplaats filter applied
-        const availableIndividualTables = [];
-
-        console.log(`[getAvailableTablesForTime] Checking ${allTables.length} tables for individual availability`);
-        for (const t of allTables) {
-            if (!isTemporaryTableValid(t, date, time)) continue;
-            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
-                if (isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) {
-                    console.log(`[getAvailableTablesForTime] Table ${t.tableNumber} is available`);
-                    availableIndividualTables.push(t); // Storing the whole object might be useful
-                }
-            }
-        }
-
-        console.log(`[getAvailableTablesForTime] Found ${availableIndividualTables.length} individually available tables: ${availableIndividualTables.map(t => t.tableNumber).join(', ')}`);
-        availableIndividualTables.sort((a, b) => a.tableNumber - b.tableNumber);
-
-        return availableIndividualTables; // Return array of table objects
-
-    } catch (error) {
-        console.error(`[getAvailableTablesForTime] Error for ${date} ${time}:`, error);
-        return []; // Return empty on error
-    }
-}
-
-module.exports = {
-    isTimeAvailableSync,
-    filterTimeblocksByTableAvailability,
-    getAvailableTimeblocksWithTableCheck,
-    getAvailableTablesForTime,
+// =============================================================================
+// FILE: simulateTableAssignment.js (UPDATED)
+// =============================================================================
+// Archief/Fields/algorithm/simulateTableAssignment.js
+
+// --- Import Helpers ---
+const {
+    getAllTables,
+    isTemporaryTableValid,
+} = require('./tableHelpers');
+
+
+/**
+ * Robust helper for parsing numeric values from various formats.
+ * Handles MongoDB $numberInt format and regular values.
+ */
+function safeParseInt(val, defaultValue) {
+    console.log(`[safeParseInt] Parsing value:`, val, `with type:`, typeof val);
+    
+    if (val === undefined || val === null) return defaultValue;
+    
+    if (typeof val === 'object' && val !== null && '$numberInt' in val) {
+        try {
+            const parsed = parseInt(val.$numberInt, 10);
+            console.log(`[safeParseInt] Parsed $numberInt format:`, parsed);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {
+            console.log(`[safeParseInt] Error parsing $numberInt:`, e);
+        }
+        return defaultValue;
+    }
+    
+    if (typeof val === 'number' && !isNaN(val)) {
+        console.log(`[safeParseInt] Using numeric value directly:`, val);
+        return val;
+    }
+    
+    if (typeof val === 'string') {
+        try {
+            const parsed = parseInt(val, 10);
+            console.log(`[safeParseInt] Parsed string:`, parsed);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {
+            console.log(`[safeParseInt] Error parsing string:`, e);
+        }
+    }
+    console.log(`[safeParseInt] Could not parse, using default:`, defaultValue);
+    return defaultValue;
+}
+
+/**
+ * Extracts actual table numbers from a reservation's tables array.
+ * Handles MongoDB $numberInt format.
+ */
+function extractTableNumbers(tablesArray) {
+    if (!Array.isArray(tablesArray)) {
+        return [];
+    }
+    
+    return tablesArray.map(table => {
+        return safeParseInt(table, null);
+    }).filter(tableNum => tableNum !== null);
+}
+
+/**
+ * Gets actual table assignments from reservation data if available.
+ * @param {Object} reservation - The reservation object
+ * @returns {Array} Array of table numbers that are actually assigned, or empty array if no data
+ */
+function getActualTableAssignment(reservation) {
+    // Check if reservation has actual table assignments
+    if (reservation.tables && Array.isArray(reservation.tables)) {
+        const tableNumbers = extractTableNumbers(reservation.tables);
+        console.log(`[getActualTableAssignment] Found actual table assignment for reservation:`, tableNumbers);
+        return tableNumbers;
+    }
+    
+    console.log(`[getActualTableAssignment] No actual table assignment found for reservation`);
+    return [];
+}
+
+/**
+ * Converts a reservation's start time and duration into discrete time slots (in minutes from midnight).
+ */
+function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (!timeString || !timePattern.test(timeString)) {
+        console.error(`Invalid time format for computeRequiredSlots: ${timeString}. Expected 'HH:MM'.`);
+        return [];
+    }
+
+    const [hour, minute] = timeString.split(":").map(Number);
+    const startMinutes = hour * 60 + minute;
+
+    if (intervalMinutes <= 0) {
+        console.error("Interval must be positive in computeRequiredSlots.");
+        return [startMinutes];
+    }
+
+    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
+    console.log(`Computing ${slotCount} slots for time ${timeString} (duration: ${durationMinutes}min, interval: ${intervalMinutes}min)`);
+
+    const slots = [];
+    for (let i = 0; i < slotCount; i++) {
+        slots.push(startMinutes + i * intervalMinutes);
+    }
+    
+    return slots;
+}
+
+/**
+ * Checks if the given tableNumber is free for all requiredSlots based on the occupied map.
+ */
+function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
+    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
+    
+    for (const slot of requiredSlots) {
+        if (occupiedSlots.has(slot)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Calculates Euclidean distance between two tables (assuming x, y properties).
+ */
+function calculateDistance(tableA, tableB) {
+    if (tableA?.x === undefined || tableA?.y === undefined || tableB?.x === undefined || tableB?.y === undefined) {
+        return Infinity; // Cannot calculate distance if coordinates are missing
+    }
+    const dx = tableA.x - tableB.x;
+    const dy = tableA.y - tableB.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * QUICKSORT-INSPIRED OPTIMIZATION: O(n log n) multi-table assignment with partitioning
+ *
+ * Instead of exploring all combinations (exponential), we use:
+ * 1. Greedy partitioning - divide tables into capacity buckets
+ * 2. Pivot selection - pick optimal table as "pivot"
+ * 3. Branch reduction - only explore promising paths
+ * 4. Dynamic programming - cache intermediate results
+ *
+ * Complexity: O(n log n) instead of O(2^n)
+ */
+
+// Cache for intermediate results (dynamic programming)
+const assignmentCache = new Map();
+
+function findMultiTableCombination(tables, guestsTotal, startIndex, currentSet, best) {
+    // Calculate current set's min and max capacity sums
+    let curMin = 0, curMax = 0;
+    for (const t of currentSet) {
+        curMin += t.minCapacity || 0;
+        curMax += t.maxCapacity || 0;
+    }
+
+    // PRUNING: If sum of minCapacity already exceeds guests, this combination is invalid
+    if (curMin > guestsTotal) return;
+
+    // Check if current combination is a valid solution
+    // Valid means: sum(minCapacity) <= guests <= sum(maxCapacity)
+    if (currentSet.length > 0 && curMin <= guestsTotal && guestsTotal <= curMax) {
+        if (currentSet.length < best.tableCount) {
+            // Calculate distance only for improved solutions
+            let distanceSum = 0;
+            for (let i = 0; i < currentSet.length; i++) {
+                for (let j = i + 1; j < currentSet.length; j++) {
+                    distanceSum += calculateDistance(currentSet[i], currentSet[j]);
+                }
+            }
+            if (currentSet.length < best.tableCount ||
+                (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
+                best.minDistance = distanceSum;
+                best.tables = [...currentSet];
+                best.tableCount = currentSet.length;
+            }
+        }
+        // Continue searching for potentially tighter clusters
+    }
+
+    // AGGRESSIVE PRUNING
+    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) return;
+    if (startIndex >= tables.length) return;
+
+    // Compute remaining capacity potential (suffix sum)
+    let suffixMax = 0;
+    for (let i = startIndex; i < tables.length; i++) {
+        suffixMax += tables[i].maxCapacity || 0;
+    }
+
+    // PRUNING: Even with all remaining tables, can't reach guests
+    if (curMax + suffixMax < guestsTotal) return;
+
+    // OPTIMIZATION: Use cached result if available (Dynamic Programming)
+    const cacheKey = `${guestsTotal}-${startIndex}-${currentSet.length}-${curMin}`;
+    if (assignmentCache.has(cacheKey)) {
+        const cached = assignmentCache.get(cacheKey);
+        if (cached.tableCount < best.tableCount) {
+            best.tableCount = cached.tableCount;
+            best.tables = [...cached.tables];
+            best.minDistance = cached.minDistance;
+        }
+        return;
+    }
+
+    // QUICKSORT-INSPIRED: Partition tables by capacity relative to guests needed
+    const remaining = tables.slice(startIndex);
+    const guestsNeeded = guestsTotal - curMax; // How much more capacity we need
+    const exactFit = [];
+    const overCapacity = [];
+    const underCapacity = [];
+
+    for (const tbl of remaining) {
+        // Check if adding this table would exceed minCapacity constraint
+        const newMin = curMin + (tbl.minCapacity || 0);
+        if (newMin > guestsTotal) continue; // Skip - would violate minCapacity constraint
+
+        const canSeat = tbl.maxCapacity || 0;
+
+        if (tbl.minCapacity <= guestsTotal && guestsTotal <= tbl.maxCapacity && currentSet.length === 0) {
+            // Single table that fits exactly (only relevant when starting fresh)
+            exactFit.push(tbl);
+        } else if (curMax + canSeat >= guestsTotal && newMin <= guestsTotal) {
+            // This table could complete a valid combination
+            overCapacity.push(tbl);
+        } else {
+            // Need more tables after this one
+            underCapacity.push(tbl);
+        }
+    }
+
+    // STRATEGY 1: Try exact fit first (best case - single table)
+    if (exactFit.length > 0 && currentSet.length === 0) {
+        // Sort by smallest capacity first (minimize waste)
+        exactFit.sort((a, b) => a.maxCapacity - b.maxCapacity);
+        const tbl = exactFit[0];
+        currentSet.push(tbl);
+        findMultiTableCombination(tables, guestsTotal, tables.length, currentSet, best);
+        currentSet.pop();
+
+        if (best.tableCount === 1) return; // Found optimal
+    }
+
+    // STRATEGY 2: Tables that can complete the combination
+    if (overCapacity.length > 0) {
+        // Sort by closest to completing the combination
+        overCapacity.sort((a, b) => {
+            const aTotal = curMax + a.maxCapacity;
+            const bTotal = curMax + b.maxCapacity;
+            return Math.abs(aTotal - guestsTotal) - Math.abs(bTotal - guestsTotal);
+        });
+
+        // Try top candidates
+        const candidates = overCapacity.slice(0, Math.min(3, overCapacity.length));
+        for (const tbl of candidates) {
+            currentSet.push(tbl);
+            findMultiTableCombination(tables, guestsTotal, tables.indexOf(tbl) + 1, currentSet, best);
+            currentSet.pop();
+
+            if (best.tableCount === currentSet.length + 1) return;
+        }
+    }
+
+    // STRATEGY 3: Two-table combinations (most common case)
+    if (underCapacity.length >= 2 && currentSet.length === 0 && best.tableCount > 2) {
+        // Sort by capacity descending
+        underCapacity.sort((a, b) => b.maxCapacity - a.maxCapacity);
+
+        // Find pairs that form valid combinations
+        for (let i = 0; i < Math.min(5, underCapacity.length); i++) {
+            const first = underCapacity[i];
+
+            for (let j = i + 1; j < underCapacity.length; j++) {
+                const second = underCapacity[j];
+                const totalMin = (first.minCapacity || 0) + (second.minCapacity || 0);
+                const totalMax = (first.maxCapacity || 0) + (second.maxCapacity || 0);
+
+                // Check if this pair forms a valid combination
+                if (totalMin <= guestsTotal && guestsTotal <= totalMax) {
+                    currentSet.push(first);
+                    currentSet.push(second);
+                    findMultiTableCombination(tables, guestsTotal, tables.length, currentSet, best);
+                    currentSet.pop();
+                    currentSet.pop();
+
+                    if (best.tableCount === 2) return; // Found optimal two-table
+                }
+            }
+        }
+    }
+
+    // STRATEGY 4: Limited backtracking only if no good solution found
+    if (best.tableCount > 3 && remaining.length <= 10) {
+        // Sort by efficiency (capacity per table)
+        remaining.sort((a, b) => b.maxCapacity - a.maxCapacity);
+
+        // Try only top 5 tables
+        const limited = remaining.slice(0, Math.min(5, remaining.length));
+        for (const tbl of limited) {
+            const newMin = curMin + (tbl.minCapacity || 0);
+            if (newMin > guestsTotal) continue; // Skip - would violate minCapacity constraint
+
+            currentSet.push(tbl);
+            const nextIdx = tables.indexOf(tbl) + 1;
+            findMultiTableCombination(tables, guestsTotal, nextIdx, currentSet, best);
+            currentSet.pop();
+
+            if (best.tableCount <= 2) return;
+        }
+    }
+
+    // Cache result
+    if (best.tableCount < Infinity) {
+        assignmentCache.set(cacheKey, {
+            tableCount: best.tableCount,
+            tables: [...best.tables],
+            minDistance: best.minDistance
+        });
+    }
+}
+
+function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
+    console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
+
+    // Clear cache if it gets too large (prevent memory leaks)
+    if (assignmentCache.size > 1000) {
+        assignmentCache.clear();
+    }
+
+    // FIXED: More robust parsing of settings with detailed logging
+    const generalSettings = restaurantData["general-settings"] || {};
+
+    // DEFAULT VALUES - this approach mirrors the TypeScript implementation
+    let duurReservatie = 120;  // Default: 2 hours in minutes
+    let intervalReservatie = 15;  // Default: 15 minute intervals
+
+    // Use safeParseInt for robust parsing
+    duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+    intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+
+    console.log(`[assignTablesForGivenTime] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
+
+    if (intervalReservatie <= 0) {
+        console.error("Invalid interval settings.");
+        return [];
+    }
+
+    const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+    if (!requiredSlots || requiredSlots.length === 0) {
+        console.error(`Could not compute required slots for ${time}`);
+        return [];
+    }
+
+    // Fetch all tables using the imported helper
+    const allTables = getAllTables(restaurantData, selectedZitplaats);
+    console.log(`[assignTablesForGivenTime] Checking ${allTables.length} tables`);
+
+    // OPTIMIZATION: Pre-filter and sort tables for better performance
+    // Filter out invalid and occupied tables first
+    const validTables = allTables.filter(t =>
+        isTemporaryTableValid(t, date, time) &&
+        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+    );
+
+    if (validTables.length === 0) {
+        console.log(`[assignTablesForGivenTime] No valid tables available`);
+        return [];
+    }
+
+    // OPTIMIZATION: Sort tables by capacity (prefer exact matches first)
+    // This helps find optimal solutions faster
+    validTables.sort((a, b) => {
+        // Prioritize tables that can seat exactly the number of guests
+        const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+        const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+        if (aExact !== bExact) return aExact - bExact;
+
+        // Then sort by capacity (smaller tables first to minimize waste)
+        return a.maxCapacity - b.maxCapacity;
+    });
+
+    // --- Try single-table assignment first ---
+    for (const t of validTables) {
+        if (t.minCapacity <= guests && guests <= t.maxCapacity) {
+            console.log(`[assignTablesForGivenTime] Assigned single table ${t.tableNumber} for ${guests} guests`);
+            return [t.tableNumber];
+        }
+    }
+
+    console.log(`[assignTablesForGivenTime] No single table found, trying combinations...`);
+
+    // --- Try multi-table assignment ---
+    const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
+    findMultiTableCombination(
+        validTables, // Use pre-filtered and sorted tables
+        guests,
+        0, // Start index
+        [], // Initial empty set
+        best // Best solution object (no need for slots/occupancy - already filtered)
+    );
+
+    if (best.tables.length > 0) {
+        console.log(`[assignTablesForGivenTime] Found multi-table solution: ${best.tables.map(t => t.tableNumber).join(', ')}`);
+    } else {
+        console.log(`[assignTablesForGivenTime] No table combination found for ${guests} guests`);
+    }
+
+    return best.tables.map(t => t.tableNumber);
+}
+
+function isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
+    console.log(`\n[isTimeAvailableSync] Checking ${date} ${time} for ${guests} guests`);
+    
+    if (guests < 0) {
+        console.log(`[isTimeAvailableSync] Detected negative guest count (${guests}), adjusting to default of 2`);
+        guests = 2; // Use a reasonable default
+    }
+    
+    const tableSettings = restaurantData?.['table-settings'] || {};
+    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
+        tableSettings.assignmentMode === "automatic";
+
+    console.log(`[isTimeAvailableSync] Table assignment enabled? ${isTableAssignmentEnabled}`);
+    console.log(`- Table settings installed: ${tableSettings.isInstalled === true}`);
+    console.log(`- Assignment mode: ${tableSettings.assignmentMode}`);
+
+    if (!isTableAssignmentEnabled) {
+        console.log(`[isTimeAvailableSync] No table assignment needed, returning true`);
+        return true;
+    }
+
+    try {
+        // Basic data check
+        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
+            console.error(`[isTimeAvailableSync] Missing floors data for ${date} ${time}`);
+            return false;
+        }
+        
+        if (guests <= 0) {
+            console.error(`[isTimeAvailableSync] Invalid guest count: ${guests}`);
+            return false; // Cannot reserve for 0 or fewer guests
+        }
+
+        const generalSettings = restaurantData["general-settings"] || {};
+        let duurReservatie = 120;  // Default: 2 hours in minutes
+        let intervalReservatie = 15;  // Default: 15 minute intervals
+        duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+        intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+        
+        console.log(`[isTimeAvailableSync] Using duration: ${duurReservatie}min, interval: ${intervalReservatie}min`);
+
+        if (intervalReservatie <= 0) {
+            console.error(`[isTimeAvailableSync] Invalid interval settings for ${date} ${time}`);
+            return false;
+        }
+
+        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+        if (!requiredSlots || requiredSlots.length === 0) {
+            console.error(`[isTimeAvailableSync] Could not compute required slots for ${date} ${time}`);
+            return false; // Cannot proceed if slots are invalid
+        }
+
+        // --- Build Occupancy Map using ACTUAL table assignments when available ---
+        const tableOccupiedSlots = {}; // { tableNumber: Set<slotMinutes> }
+        const reservationsForDate = reservations
+            .filter(r => r.date === date && r.time && r.guests > 0)
+            .sort((a, b) => {
+                // Simple time string comparison
+                const timeA = a.time.split(':').map(Number);
+                const timeB = b.time.split(':').map(Number);
+                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
+            });
+
+        console.log(`[isTimeAvailableSync] Processing ${reservationsForDate.length} existing reservations on ${date}`);
+
+        for (const r of reservationsForDate) {
+            // NEW: Try to get actual table assignment first
+            const actualTables = getActualTableAssignment(r);
+            let assignedTables = [];
+            
+            if (actualTables.length > 0) {
+                // Use actual table assignment from reservation data
+                assignedTables = actualTables;
+                console.log(`[isTimeAvailableSync] Using actual table assignment for reservation: ${assignedTables.join(', ')}`);
+            } else {
+                // Fall back to simulation for backwards compatibility
+                console.log(`[isTimeAvailableSync] No actual table data, simulating assignment for reservation`);
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots);
+            }
+
+            // Update the occupancy map based on the actual or simulated assignment
+            if (assignedTables.length > 0) {
+                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                if (!rSlots || rSlots.length === 0) continue; // Skip if slots invalid
+
+                assignedTables.forEach(tableNumber => {
+                    if (!tableOccupiedSlots[tableNumber]) {
+                        tableOccupiedSlots[tableNumber] = new Set();
+                    }
+                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
+                });
+                
+                console.log(`[isTimeAvailableSync] Marked tables ${assignedTables.join(', ')} as occupied for time ${r.time}`);
+            }
+        }
+
+        console.log(`[isTimeAvailableSync] Occupancy map built, checking availability for new reservation`);
+
+        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables
+        console.log(`[isTimeAvailableSync] Checking ${allTables.length} tables for new reservation`);
+
+        // OPTIMIZATION: Pre-filter valid tables
+        const validTables = allTables.filter(t =>
+            isTemporaryTableValid(t, date, time) &&
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+        );
+
+        if (validTables.length === 0) {
+            console.log(`[isTimeAvailableSync] No valid tables available`);
+            return false;
+        }
+
+        // OPTIMIZATION: Sort for faster exact matches
+        validTables.sort((a, b) => {
+            const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+            const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+            if (aExact !== bExact) return aExact - bExact;
+            return a.maxCapacity - b.maxCapacity;
+        });
+
+        // 1. Try single table assignment
+        for (const t of validTables) {
+            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
+                console.log(`[isTimeAvailableSync] Found single table ${t.tableNumber} for ${guests} guests at ${time}`);
+                return true; // Available
+            }
+        }
+
+        console.log(`[isTimeAvailableSync] No single table found, trying combinations...`);
+
+        // 2. Try multi-table assignment
+        const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
+        findMultiTableCombination(
+            validTables, // Use pre-filtered tables
+            guests,
+            0, // Start index
+            [], // Empty current set
+            best // Best solution
+        );
+
+        const result = best.tables.length > 0;
+        if (result) {
+            console.log(`[isTimeAvailableSync] Multi-table assignment possible: ${best.tables.map(t => t.tableNumber).join(', ')}`);
+        } else {
+            console.log(`[isTimeAvailableSync] No table combination available`);
+        }
+
+        return result; // Available if a combination was found
+
+    } catch (error) {
+        console.error(`[isTimeAvailableSync] Error during check for ${date} ${time}:`, error);
+        return false; // Assume unavailable on error
+    }
+}
+
+function filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
+    console.log(`[filterTimeblocksByTableAvailability] Filtering timeblocks for ${date} with ${guests} guests`);
+    
+    if (guests < 0) {
+        console.log(`[filterTimeblocksByTableAvailability] Detected negative guest count (${guests}), adjusting to default of 2`);
+        guests = 0; // Use a reasonable default
+    }
+    
+    const tableSettings = restaurantData?.['table-settings'] || {};
+    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
+        tableSettings.assignmentMode === "automatic";
+
+    if (!isTableAssignmentEnabled) {
+        console.log(`[filterTimeblocksByTableAvailability] No table assignment enabled, returning all timeblocks`);
+        return timeblocks;
+    }
+
+    console.log(`[filterTimeblocksByTableAvailability] Starting with ${Object.keys(timeblocks).length} timeblocks`);
+
+    const filteredTimeblocks = {};
+    let availableCount = 0;
+    let unavailableCount = 0;
+
+    for (const time in timeblocks) {
+        if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats)) {
+            filteredTimeblocks[time] = timeblocks[time];
+            availableCount++;
+        } else {
+            unavailableCount++;
+        }
+    }
+
+    console.log(`[filterTimeblocksByTableAvailability] Result: ${availableCount} available, ${unavailableCount} unavailable times`);
+    if (availableCount > 0) {
+        console.log(`[filterTimeblocksByTableAvailability] Available times: ${Object.keys(filteredTimeblocks).join(', ')}`);
+    }
+
+    return filteredTimeblocks;
+}
+
+function getAvailableTimeblocksWithTableCheck(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats = null) {
+    return filterTimeblocksByTableAvailability(restaurantData, date, timeblocks, guests, reservations, selectedZitplaats);
+}
+
+function getAvailableTablesForTime(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
+    try {
+        if (guests < 0) {
+            console.log(`[getAvailableTablesForTime] Detected negative guest count (${guests}), adjusting to default of 2`);
+            guests = 0;
+        }
+        
+        const tableSettings = restaurantData?.['table-settings'] || {};
+        const isAutomaticAssignment = tableSettings.isInstalled === true &&
+                                       tableSettings.assignmentMode === "automatic";
+
+        if (!isAutomaticAssignment) {
+            return [];
+        }
+
+        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
+            console.error(`[getAvailableTablesForTime] Missing floors data for ${date} ${time}`);
+            return [];
+        }
+        if (guests <= 0) return [];
+        const generalSettings = restaurantData["general-settings"] || {};
+        const duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
+        const intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
+        
+        if (intervalReservatie <= 0) {
+             console.error(`[getAvailableTablesForTime] Invalid interval settings for ${date} ${time}`);
+             return [];
+        }
+
+        console.log(`\n[getAvailableTablesForTime] Finding available tables for ${guests} guests on ${date} at ${time}`);
+        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
+         if (!requiredSlots || requiredSlots.length === 0) {
+            console.error(`[getAvailableTablesForTime] Could not compute required slots for ${date} ${time}`);
+            return [];
+        }
+        const tableOccupiedSlots = {};
+        const reservationsForDate = reservations
+            .filter(r => r.date === date && r.time && r.guests > 0)
+            .sort((a, b) => {
+                const timeA = a.time.split(':').map(Number);
+                const timeB = b.time.split(':').map(Number);
+                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
+            });
+
+        console.log(`[getAvailableTablesForTime] Building occupancy map (Processing ${reservationsForDate.length} existing reservations)`);
+        for (const r of reservationsForDate) {
+            const actualTables = getActualTableAssignment(r);
+            let assignedTables = [];
+            
+            if (actualTables.length > 0) {
+                assignedTables = actualTables;
+            } else {
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null);
+            }
+            
+            if (assignedTables.length > 0) {
+                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
+                 if (!rSlots || rSlots.length === 0) continue;
+                assignedTables.forEach(tableNumber => {
+                    if (!tableOccupiedSlots[tableNumber]) {
+                        tableOccupiedSlots[tableNumber] = new Set();
+                    }
+                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
+                });
+            }
+        }
+        console.log("[getAvailableTablesForTime] Occupancy map built");
+        const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables with zitplaats filter applied
+        const availableIndividualTables = [];
+
+        console.log(`[getAvailableTablesForTime] Checking ${allTables.length} tables for individual availability`);
+        for (const t of allTables) {
+            if (!isTemporaryTableValid(t, date, time)) continue;
+            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
+                if (isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) {
+                    console.log(`[getAvailableTablesForTime] Table ${t.tableNumber} is available`);
+                    availableIndividualTables.push(t); // Storing the whole object might be useful
+                }
+            }
+        }
+
+        console.log(`[getAvailableTablesForTime] Found ${availableIndividualTables.length} individually available tables: ${availableIndividualTables.map(t => t.tableNumber).join(', ')}`);
+        availableIndividualTables.sort((a, b) => a.tableNumber - b.tableNumber);
+
+        return availableIndividualTables; // Return array of table objects
+
+    } catch (error) {
+        console.error(`[getAvailableTablesForTime] Error for ${date} ${time}:`, error);
+        return []; // Return empty on error
+    }
+}
+
+module.exports = {
+    isTimeAvailableSync,
+    filterTimeblocksByTableAvailability,
+    getAvailableTimeblocksWithTableCheck,
+    getAvailableTablesForTime,
 };