vip-coordinator/backend-old-20260125/dist/services/driverConflictService.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class DriverConflictService {
    // Check for conflicts when assigning a driver to an event
    checkDriverConflicts(driverId, newEvent, allSchedules, drivers) {
        const conflicts = [];
        const driver = drivers.find(d => d.id === driverId);
        if (!driver)
            return conflicts;
        // Get all events assigned to this driver
        const driverEvents = this.getDriverEvents(driverId, allSchedules);
        const newStartTime = new Date(newEvent.startTime);
        const newEndTime = new Date(newEvent.endTime);
        for (const existingEvent of driverEvents) {
            const existingStart = new Date(existingEvent.startTime);
            const existingEnd = new Date(existingEvent.endTime);
            // Check for direct time overlap
            if (this.hasTimeOverlap(newStartTime, newEndTime, existingStart, existingEnd)) {
                conflicts.push({
                    type: 'overlap',
                    severity: 'high',
                    message: `Direct time conflict with "${existingEvent.title}" for ${existingEvent.vipName}`,
                    conflictingEvent: existingEvent
                });
            }
            // Check for tight turnaround (less than 15 minutes between events)
            else {
                const timeBetween = this.getTimeBetweenEvents(newStartTime, newEndTime, existingStart, existingEnd);
                if (timeBetween !== null && timeBetween < 15) {
                    conflicts.push({
                        type: 'tight_turnaround',
                        severity: timeBetween < 5 ? 'high' : 'medium',
                        message: `Only ${timeBetween} minutes between events. Previous: "${existingEvent.title}"`,
                        conflictingEvent: existingEvent,
                        timeDifference: timeBetween
                    });
                }
            }
        }
        return conflicts;
    }
    // Get availability status for all drivers for a specific time slot
    getDriverAvailability(eventTime, allSchedules, drivers) {
        return drivers.map(driver => {
            const conflicts = this.checkDriverConflicts(driver.id, eventTime, allSchedules, drivers);
            const driverEvents = this.getDriverEvents(driver.id, allSchedules);
            let status = 'available';
            if (conflicts.length > 0) {
                const hasOverlap = conflicts.some(c => c.type === 'overlap');
                const hasTightTurnaround = conflicts.some(c => c.type === 'tight_turnaround');
                if (hasOverlap) {
                    status = 'overlapping';
                }
                else if (hasTightTurnaround) {
                    status = 'tight_turnaround';
                }
            }
            else if (driverEvents.length > 0) {
                status = 'scheduled';
            }
            return {
                driverId: driver.id,
                driverName: driver.name,
                status,
                assignmentCount: driverEvents.length,
                conflicts,
                currentAssignments: driverEvents
            };
        });
    }
    // Get all events assigned to a specific driver
    getDriverEvents(driverId, allSchedules) {
        const driverEvents = [];
        Object.entries(allSchedules).forEach(([vipId, events]) => {
            events.forEach(event => {
                if (event.assignedDriverId === driverId) {
                    driverEvents.push({
                        ...event,
                        vipId,
                        vipName: event.title // We'll need to get actual VIP name from VIP data
                    });
                }
            });
        });
        // Sort by start time
        return driverEvents.sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime());
    }
    // Check if two time periods overlap
    hasTimeOverlap(start1, end1, start2, end2) {
        return start1 < end2 && start2 < end1;
    }
    // Get minutes between two events (null if they overlap)
    getTimeBetweenEvents(newStart, newEnd, existingStart, existingEnd) {
        // If new event is after existing event
        if (newStart >= existingEnd) {
            return Math.floor((newStart.getTime() - existingEnd.getTime()) / (1000 * 60));
        }
        // If new event is before existing event
        else if (newEnd <= existingStart) {
            return Math.floor((existingStart.getTime() - newEnd.getTime()) / (1000 * 60));
        }
        // Events overlap
        return null;
    }
    // Generate summary message for driver status
    getDriverStatusSummary(availability) {
        switch (availability.status) {
            case 'available':
                return `✅ Fully available (${availability.assignmentCount} assignments)`;
            case 'scheduled':
                return `🟡 Has ${availability.assignmentCount} assignment(s) but available for this time`;
            case 'tight_turnaround':
                const tightConflict = availability.conflicts.find(c => c.type === 'tight_turnaround');
                return `⚡ Tight turnaround - ${tightConflict?.timeDifference} min between events`;
            case 'overlapping':
                return `🔴 Time conflict with existing assignment`;
            default:
                return 'Unknown status';
        }
    }
}
exports.default = new DriverConflictService();
//# sourceMappingURL=driverConflictService.js.map