staff-script.js

// Staff Booking System JavaScript
document.addEventListener('DOMContentLoaded', function() {
    const form = document.getElementById('staff-booking-form');
    const departDateInput = document.getElementById('staff-depart-date');
    const returnDateInput = document.getElementById('staff-return-date');

    // Set minimum date to today and auto-populate departure date
    const today = new Date().toISOString().split('T')[0];
    departDateInput.setAttribute('min', today);
    returnDateInput.setAttribute('min', today);
    departDateInput.value = today;

    // Initialize staff form interactions
    setupStaffFormInteractions();
    setupStaffCustomerLookup();
    setupStaffKeyboardShortcuts();

    // Initialize custom time pickers directly
    setTimeout(() => {
        console.log('Initializing custom time pickers for staff page...');
        initializeStaffTimePickers();
        initializeLocationAutocomplete();
    }, 100);

    function setupStaffFormInteractions() {
        // Trip type change handler
        const tripTypeSelect = document.getElementById('staff-trip-type');
        const returnRow = document.getElementById('staff-return-row');
        const returnDateInput = document.getElementById('staff-return-date');
        const returnTimeInput = document.querySelector('[data-name="returnTime"] .time-value');

        tripTypeSelect.addEventListener('change', function() {
            const multiTransferSection = document.getElementById('staff-multi-transfer-section');

            if (this.value === 'return') {
                returnRow.style.display = 'grid';
                returnDateInput.setAttribute('required', 'required');
                // For custom time picker, set required on the display input
                const returnTimeDisplay = document.querySelector('[data-name="returnTime"] .time-display');
                if (returnTimeDisplay) {
                    returnTimeDisplay.setAttribute('required', 'required');
                }
                multiTransferSection.style.display = 'none';

                // Show the original pickup/dropoff/date/time rows for return trip
                const originalLocationRow = document.querySelector('.form-row-staff:has(#staff-pickup)');
                const originalDateTimeRow = document.querySelector('.form-row-staff:has(#staff-depart-date)');
                if (originalLocationRow) originalLocationRow.style.display = 'grid';
                if (originalDateTimeRow) originalDateTimeRow.style.display = 'grid';
            } else if (this.value === 'multi-transfer') {
                returnRow.style.display = 'none';
                returnDateInput.removeAttribute('required');
                // Clear return time inputs
                const returnTimeDisplay = document.querySelector('[data-name="returnTime"] .time-display');
                const returnTimeValue = document.querySelector('[data-name="returnTime"] .time-value');
                if (returnTimeDisplay) {
                    returnTimeDisplay.removeAttribute('required');
                    returnTimeDisplay.value = '';
                }
                if (returnTimeValue) {
                    returnTimeValue.value = '';
                }
                returnDateInput.value = '';

                // Hide the original pickup/dropoff/date/time row for multi-transfer
                const originalLocationRow = document.querySelector('.form-row-staff:has(#staff-pickup)');
                const originalDateTimeRow = document.querySelector('.form-row-staff:has(#staff-depart-date)');
                if (originalLocationRow) originalLocationRow.style.display = 'none';
                if (originalDateTimeRow) originalDateTimeRow.style.display = 'none';

                multiTransferSection.style.display = 'block';
                // Initialize with 2 transfers if none exist
                if (document.querySelectorAll('.transfer-leg').length === 0) {
                    addTransferLeg();
                    addTransferLeg();
                }
            } else {
                returnRow.style.display = 'none';
                returnDateInput.removeAttribute('required');
                // For custom time picker, remove required from display input and clear values
                const returnTimeDisplay = document.querySelector('[data-name="returnTime"] .time-display');
                const returnTimeValue = document.querySelector('[data-name="returnTime"] .time-value');
                if (returnTimeDisplay) {
                    returnTimeDisplay.removeAttribute('required');
                    returnTimeDisplay.value = '';
                }
                if (returnTimeValue) {
                    returnTimeValue.value = '';
                }
                returnDateInput.value = '';
                multiTransferSection.style.display = 'none';

                // Show the original pickup/dropoff/date/time rows for one-way
                const originalLocationRow = document.querySelector('.form-row-staff:has(#staff-pickup)');
                const originalDateTimeRow = document.querySelector('.form-row-staff:has(#staff-depart-date)');
                if (originalLocationRow) originalLocationRow.style.display = 'grid';
                if (originalDateTimeRow) originalDateTimeRow.style.display = 'grid';
            }
            calculatePrice();
        });

        // Customer type change handler
        const customerTypeSelect = document.getElementById('staff-customer-type');
        const agentRow = document.getElementById('staff-agent-row');

        customerTypeSelect.addEventListener('change', function() {
            if (this.value === 'agent') {
                agentRow.style.display = 'grid';
            } else {
                agentRow.style.display = 'none';
            }
            calculatePrice();
            updateAllTransferPricing();
        });

        // Passenger count change handler
        const passengersSelect = document.getElementById('staff-passengers');
        const travellersGroup = document.getElementById('staff-travellers-group');

        passengersSelect.addEventListener('change', function() {
            const passengerCount = parseInt(this.value);
            if (passengerCount > 2) {
                travellersGroup.style.display = 'block';
            } else {
                travellersGroup.style.display = 'none';
                document.getElementById('staff-travellers').value = '';
            }
            calculatePrice();
            updateAllTransferPricing();
        });

        // Departure date change handler
        const departDateInput = document.getElementById('staff-depart-date');
        departDateInput.addEventListener('change', function() {
            const departDate = this.value;
            returnDateInput.setAttribute('min', departDate);

            if (returnDateInput.value && returnDateInput.value < departDate) {
                returnDateInput.value = '';
            }
            calculatePrice();
        });

        // Location and service type change handlers for price calculation
        const pickupSelect = document.getElementById('staff-pickup');
        const dropoffSelect = document.getElementById('staff-dropoff');
        const serviceTypeSelect = document.getElementById('staff-service-type');

        pickupSelect.addEventListener('change', function() {
            console.log('Pickup changed to:', this.value);
            updateAddressFields();
            calculatePrice();
        });
        dropoffSelect.addEventListener('change', function() {
            console.log('Dropoff changed to:', this.value);
            updateAddressFields();
            calculatePrice();
        });
        serviceTypeSelect.addEventListener('change', function() {
            console.log('Service type changed to:', this.value);
            calculatePrice();
            updateAllTransferPricing();
        });

        // Accommodation dropdown change handlers
        const pickupAccommodationSelect = document.getElementById('staff-pickup-accommodation');
        const dropoffAccommodationSelect = document.getElementById('staff-dropoff-accommodation');
        if (pickupAccommodationSelect) {
            pickupAccommodationSelect.addEventListener('change', function() {
                handleAccommodationChange('pickup');
            });
        }
        if (dropoffAccommodationSelect) {
            dropoffAccommodationSelect.addEventListener('change', function() {
                handleAccommodationChange('dropoff');
            });
        }

        // Clear form button
        document.getElementById('clear-form-btn').addEventListener('click', clearForm);

        // Save draft button
        document.getElementById('save-draft-btn').addEventListener('click', saveDraft);

        // Multi-transfer functionality
        const addLegBtn = document.getElementById('add-transfer-leg');
        if (addLegBtn) {
            addLegBtn.addEventListener('click', addTransferLeg);
        }
    }

    function setupStaffCustomerLookup() {
        const phoneInput = document.getElementById('staff-phone');
        const customerSuggestions = document.getElementById('staff-customer-suggestions');
        const firstNameInput = document.getElementById('staff-first-name');
        const lastNameInput = document.getElementById('staff-last-name');
        const emailInput = document.getElementById('staff-email');
        const titleSelect = document.getElementById('staff-title');
        const customerTypeSelect = document.getElementById('staff-customer-type');

        console.log('Setting up customer lookup...');
        console.log('Phone input element:', phoneInput);
        console.log('Customer suggestions element:', customerSuggestions);

        if (!phoneInput || !customerSuggestions) {
            console.error('Required customer lookup elements not found:', {
                phoneInput: !!phoneInput,
                customerSuggestions: !!customerSuggestions
            });
            return;
        }

        let lookupTimeout;

        // Mock customer database (same as public form)
        const mockCustomers = [
            {
                phone: '0400123456',
                title: 'mr',
                firstName: 'John',
                lastName: 'Smith',
                email: 'john.smith@email.com',
                customerType: 'personal'
            },
            {
                phone: '0412345678',
                title: 'mrs',
                firstName: 'Sarah',
                lastName: 'Jones',
                email: 'sarah.jones@email.com',
                customerType: 'corporate'
            },
            {
                phone: '0401234567',
                title: 'dr',
                firstName: 'John',
                lastName: 'Wilson',
                email: 'john.wilson@email.com',
                customerType: 'personal'
            },
            {
                phone: '0412356789',
                title: 'ms',
                firstName: 'Sarah',
                lastName: 'Brown',
                email: 'sarah.brown@email.com',
                customerType: 'agent'
            }
        ];

        phoneInput.addEventListener('input', function() {
            const phone = this.value.trim();
            clearTimeout(lookupTimeout);
            customerSuggestions.style.display = 'none';

            console.log('Phone input event triggered! Value:', phone, 'Length:', phone.replace(/\D/g, '').length);

            if (phone.replace(/\D/g, '').length >= 3) {
                lookupTimeout = setTimeout(() => {
                    console.log('Searching customers for:', phone);
                    searchCustomers(phone);
                }, 200); // Faster for staff
            }
        });

        console.log('Phone input event listener added successfully!');

        phoneInput.addEventListener('blur', function() {
            setTimeout(() => {
                customerSuggestions.style.display = 'none';
            }, 200);
        });

        phoneInput.addEventListener('focus', function() {
            const phone = this.value.trim();
            if (phone.replace(/\D/g, '').length >= 3) {
                searchCustomers(phone);
            }
        });

        function searchCustomers(phone) {
            const normalizedInput = phone.replace(/\D/g, '');

            const matches = mockCustomers.filter(customer => {
                const customerPhone = customer.phone.replace(/\D/g, '');
                return customerPhone.includes(normalizedInput);
            });

            if (matches.length > 0) {
                showCustomerSuggestions(matches);
            } else {
                customerSuggestions.style.display = 'none';
            }
        }

        function showCustomerSuggestions(customers) {
            customerSuggestions.innerHTML = '';

            customers.forEach(customer => {
                const suggestionDiv = document.createElement('div');
                suggestionDiv.className = 'customer-suggestion';
                suggestionDiv.innerHTML = `
                    <div class="customer-name">${customer.title ? customer.title.charAt(0).toUpperCase() + customer.title.slice(1) + ' ' : ''}${customer.firstName} ${customer.lastName}</div>
                    <div class="customer-details">${customer.email}</div>
                    <div class="customer-phone">${customer.phone}</div>
                `;

                suggestionDiv.addEventListener('click', () => {
                    selectCustomer(customer);
                });

                customerSuggestions.appendChild(suggestionDiv);
            });

            customerSuggestions.style.display = 'block';
        }

        function selectCustomer(customer) {
            phoneInput.value = customer.phone;
            titleSelect.value = customer.title;
            firstNameInput.value = customer.firstName;
            lastNameInput.value = customer.lastName;
            emailInput.value = customer.email;
            customerTypeSelect.value = customer.customerType;

            customerSuggestions.style.display = 'none';

            // Trigger agent section if customer is agent
            if (customer.customerType === 'agent') {
                document.getElementById('staff-agent-row').style.display = 'grid';
            }

            // Auto-focus next field
            document.getElementById('staff-trip-type').focus();

            calculatePrice();
        }
    }

    function setupStaffKeyboardShortcuts() {
        document.addEventListener('keydown', function(e) {
            // Ctrl+N for new booking
            if (e.ctrlKey && e.key === 'n') {
                e.preventDefault();
                clearForm();
                document.getElementById('staff-phone').focus();
            }

            // Ctrl+S for save draft
            if (e.ctrlKey && e.key === 's') {
                e.preventDefault();
                saveDraft();
            }

            // Ctrl+Enter for submit
            if (e.ctrlKey && e.key === 'Enter') {
                e.preventDefault();
                form.dispatchEvent(new Event('submit'));
            }

            // Escape to clear form
            if (e.key === 'Escape') {
                clearForm();
            }
        });
    }

    async function calculatePrice() {
        console.log('calculatePrice() function called');

        const tripType = document.getElementById('staff-trip-type').value;
        const pickup = document.getElementById('staff-pickup').value;
        const dropoff = document.getElementById('staff-dropoff').value;
        const passengers = parseInt(document.getElementById('staff-passengers').value);
        const customerType = document.getElementById('staff-customer-type').value;
        const serviceType = document.getElementById('staff-service-type').value;

        console.log('Form values:', { tripType, pickup, dropoff, passengers, customerType, serviceType });

        if (!pickup || !dropoff || !passengers || !serviceType) {
            console.log('Missing required fields for pricing');
            document.getElementById('staff-price-display').textContent = 'Select details';
            return;
        }

        try {
            const price = await calculatePriceForRoute(pickup, dropoff, passengers, serviceType, customerType, tripType);

            if (price > 0) {
                document.getElementById('staff-price-display').textContent = `$${price.toFixed(2)}`;
            } else {
                document.getElementById('staff-price-display').textContent = 'Route not available';
            }
        } catch (error) {
            console.error('Pricing calculation error:', error);
            document.getElementById('staff-price-display').textContent = 'Pricing error';
        }

        return; // Exit early - new pricing logic handles everything

        // This will be determined below based on route type

        // Rate sheet data (2025-2026 rates)
        const airportRates = {
            'kingscote-town': { // Kingscote
                1: { shared: 45.00, nett: 36.00, private: 72.00 },
                2: { shared: 90.00, nett: 72.00, private: 144.00 },
                3: { shared: 110.00, nett: 88.00, private: 176.00 },
                4: { shared: 130.00, nett: 104.00, private: 208.00 },
                5: { shared: 150.00, nett: 120.00, private: 240.00 },
                6: { shared: 170.00, nett: 136.00, private: 272.00 }
            },
            'american-river': {
                2: { shared: 105.00, nett: 84.00, private: 126.00 },
                3: { shared: 125.00, nett: 100.00, private: 150.00 },
                4: { shared: 145.00, nett: 116.00, private: 174.00 },
                5: { shared: 165.00, nett: 132.00, private: 198.00 },
                6: { shared: 185.00, nett: 148.00, private: 222.00 }
            },
            'penneshaw-ferry': { // Penneshaw
                2: { shared: 182.00, nett: 145.60, private: 218.40 },
                3: { shared: 202.00, nett: 161.60, private: 242.40 },
                4: { shared: 222.00, nett: 177.60, private: 266.40 },
                5: { shared: 242.00, nett: 193.60, private: 290.40 },
                6: { shared: 262.00, nett: 209.60, private: 314.40 }
            },
            'vivonne-bay': {
                2: { shared: 168.00, nett: 134.40, private: 201.60 },
                3: { shared: 188.00, nett: 150.40, private: 225.60 },
                4: { shared: 208.00, nett: 166.40, private: 249.60 },
                5: { shared: 228.00, nett: 182.40, private: 273.60 },
                6: { shared: 248.00, nett: 198.40, private: 297.60 }
            },
            'flinders-chase': { // Represents Southern Ocean Lodge area
                2: { shared: 315.00, nett: 252.00, private: 378.00 },
                3: { shared: 335.00, nett: 268.00, private: 402.00 },
                4: { shared: 355.00, nett: 284.00, private: 426.00 },
                5: { shared: 375.00, nett: 300.00, private: 450.00 },
                6: { shared: 395.00, nett: 316.00, private: 474.00 }
            },
            'flinders-chase-visitor-centre': {
                2: { shared: 300.00, nett: 240.00, private: 360.00 },
                3: { shared: 320.00, nett: 256.00, private: 384.00 },
                4: { shared: 340.00, nett: 272.00, private: 408.00 },
                5: { shared: 360.00, nett: 288.00, private: 432.00 },
                6: { shared: 380.00, nett: 304.00, private: 456.00 }
            },
            'emu-bay': {
                2: { shared: 94.50, nett: 75.60, private: 113.40 },
                3: { shared: 114.50, nett: 91.60, private: 137.40 },
                4: { shared: 134.50, nett: 107.60, private: 161.40 },
                5: { shared: 154.50, nett: 123.60, private: 185.40 },
                6: { shared: 174.50, nett: 139.60, private: 209.40 }
            },
            'parndana': {
                2: { shared: 133.00, nett: 106.40, private: 159.60 },
                3: { shared: 153.00, nett: 122.40, private: 183.60 },
                4: { shared: 173.00, nett: 138.40, private: 207.60 },
                5: { shared: 193.00, nett: 154.40, private: 231.60 },
                6: { shared: 213.00, nett: 170.40, private: 255.60 }
            }
        };

        // Kingscote to other destinations rates
        const kingscoteRates = {
            'kingscote-airport': { // Kingscote to Airport
                1: { shared: 36.00, nett: 28.80, private: 57.60 },
                2: { shared: 72.00, nett: 57.60, private: 115.20 },
                3: { shared: 92.00, nett: 73.60, private: 147.20 },
                4: { shared: 112.00, nett: 89.60, private: 179.20 },
                5: { shared: 132.00, nett: 105.60, private: 211.20 },
                6: { shared: 152.00, nett: 121.60, private: 243.20 }
            },
            'american-river': {
                2: { shared: 138.60, nett: 110.88, private: 166.32 },
                3: { shared: 158.60, nett: 126.88, private: 190.32 },
                4: { shared: 178.60, nett: 142.88, private: 214.32 },
                5: { shared: 198.60, nett: 158.88, private: 238.32 },
                6: { shared: 218.60, nett: 174.88, private: 262.32 }
            },
            'penneshaw-ferry': {
                2: { shared: 198.00, nett: 158.40, private: 237.60 },
                3: { shared: 218.00, nett: 174.40, private: 261.60 },
                4: { shared: 238.00, nett: 190.40, private: 285.60 },
                5: { shared: 258.00, nett: 206.40, private: 309.60 },
                6: { shared: 278.00, nett: 222.40, private: 333.60 }
            },
            'vivonne-bay': {
                2: { shared: 198.00, nett: 158.40, private: 237.60 },
                3: { shared: 218.00, nett: 174.40, private: 261.60 },
                4: { shared: 238.00, nett: 190.40, private: 285.60 },
                5: { shared: 258.00, nett: 206.40, private: 309.60 },
                6: { shared: 278.00, nett: 222.40, private: 333.60 }
            },
            'flinders-chase': { // Southern Ocean Lodge area
                2: { shared: 326.70, nett: 261.36, private: 392.04 },
                3: { shared: 346.70, nett: 277.36, private: 416.04 },
                4: { shared: 366.70, nett: 293.36, private: 440.04 },
                5: { shared: 386.70, nett: 309.36, private: 464.04 },
                6: { shared: 406.70, nett: 325.36, private: 488.04 }
            },
            'emu-bay': {
                2: { shared: 89.10, nett: 71.28, private: 106.92 },
                3: { shared: 109.10, nett: 87.28, private: 130.92 },
                4: { shared: 129.10, nett: 103.28, private: 154.92 },
                5: { shared: 149.10, nett: 119.28, private: 178.92 },
                6: { shared: 169.10, nett: 135.28, private: 202.92 }
            },
            'parndana': {
                2: { shared: 151.80, nett: 121.44, private: 182.16 },
                3: { shared: 171.80, nett: 137.44, private: 206.16 },
                4: { shared: 191.80, nett: 153.44, private: 230.16 },
                5: { shared: 211.80, nett: 169.44, private: 254.16 },
                6: { shared: 231.80, nett: 185.44, private: 278.16 }
            }
        };

        // Penneshaw to other destinations rates
        const penneshawRates = {
            'kingscote-town': {
                2: { shared: 198.00, nett: 158.40, private: 237.60 },
                3: { shared: 218.00, nett: 174.40, private: 261.60 },
                4: { shared: 238.00, nett: 190.40, private: 285.60 },
                5: { shared: 258.00, nett: 206.40, private: 309.60 },
                6: { shared: 278.00, nett: 222.40, private: 333.60 }
            },
            'american-river': {
                2: { shared: 132.00, nett: 105.60, private: 158.40 },
                3: { shared: 152.00, nett: 121.60, private: 182.40 },
                4: { shared: 172.00, nett: 137.60, private: 206.40 },
                5: { shared: 192.00, nett: 153.60, private: 230.40 },
                6: { shared: 212.00, nett: 169.60, private: 254.40 }
            },
            'parndana': {
                2: { shared: 257.40, nett: 205.92, private: 308.88 },
                3: { shared: 277.40, nett: 221.92, private: 332.88 },
                4: { shared: 297.40, nett: 237.92, private: 356.88 },
                5: { shared: 317.40, nett: 253.92, private: 380.88 },
                6: { shared: 337.40, nett: 269.92, private: 404.88 }
            },
            'vivonne-bay': {
                2: { shared: 297.00, nett: 237.60, private: 356.40 },
                3: { shared: 317.00, nett: 253.60, private: 380.40 },
                4: { shared: 337.00, nett: 269.60, private: 404.40 },
                5: { shared: 357.00, nett: 285.60, private: 428.40 },
                6: { shared: 377.00, nett: 301.60, private: 452.40 }
            },
            'emu-bay': {
                2: { shared: 227.70, nett: 182.16, private: 273.24 },
                3: { shared: 247.70, nett: 198.16, private: 297.24 },
                4: { shared: 267.70, nett: 214.16, private: 321.24 },
                5: { shared: 287.70, nett: 230.16, private: 345.24 },
                6: { shared: 307.70, nett: 246.16, private: 369.24 }
            },
            'kingscote-airport': {
                2: { shared: 171.60, nett: 137.28, private: 205.92 },
                3: { shared: 191.60, nett: 153.28, private: 229.92 },
                4: { shared: 211.60, nett: 169.28, private: 253.92 },
                5: { shared: 231.60, nett: 185.28, private: 277.92 },
                6: { shared: 251.60, nett: 201.28, private: 301.92 }
            },
            'flinders-chase': { // Southern Ocean Lodge
                2: { shared: 336.60, nett: 269.28, private: 403.92 },
                3: { shared: 356.60, nett: 285.28, private: 427.92 },
                4: { shared: 376.60, nett: 301.28, private: 451.92 },
                5: { shared: 396.60, nett: 317.28, private: 475.92 },
                6: { shared: 416.60, nett: 333.28, private: 499.92 }
            }
        };

        // Determine which rate sheet to use and get destination
        let rateSheet, destination;
        if (pickup === 'kingscote-airport') {
            rateSheet = airportRates;
            destination = dropoff;
        } else if (dropoff === 'kingscote-airport') {
            rateSheet = airportRates;
            destination = pickup;
        } else if (pickup === 'kingscote-town') {
            rateSheet = kingscoteRates;
            destination = dropoff;
        } else if (dropoff === 'kingscote-town') {
            rateSheet = kingscoteRates;
            destination = pickup;
        } else if (pickup === 'penneshaw-ferry') {
            rateSheet = penneshawRates;
            destination = dropoff;
        } else if (dropoff === 'penneshaw-ferry') {
            rateSheet = penneshawRates;
            destination = pickup;
        } else {
            document.getElementById('staff-price-display').textContent = 'Route not available';
            return;
        }

        // Validate single passenger booking - only allowed for Airport ↔ Kingscote
        if (passengers === 1 && !(
            (pickup === 'kingscote-airport' && dropoff === 'kingscote-town') ||
            (pickup === 'kingscote-town' && dropoff === 'kingscote-airport')
        )) {
            document.getElementById('staff-price-display').textContent = 'Min 2 PAX for this route';
            return;
        }

        // Get passenger group (6+ uses 6 rate)
        let paxGroup = passengers;
        if (passengers > 6) paxGroup = 6; // 6+ uses 6 passenger rate

        // Get rate for destination and passenger count
        const destinationRates = rateSheet[destination];
        if (!destinationRates) {
            document.getElementById('staff-price-display').textContent = 'Destination not found';
            return;
        }

        const rates = destinationRates[paxGroup];
        if (!rates) {
            document.getElementById('staff-price-display').textContent = 'Rate not available';
            return;
        }

        let price = 0;

        // Apply pricing based on customer type and service type
        if (customerType === 'personal') {
            // Personal customers get shared RRP or private RRP
            price = serviceType === 'shared' ? rates.shared : rates.private;
        } else if (customerType === 'agent') {
            // Agents get nett price (shared nett or private calculated from nett)
            if (serviceType === 'shared') {
                price = rates.nett;
            } else {
                // Private nett = shared nett * (private RRP / shared RRP)
                price = rates.nett * (rates.private / rates.shared);
            }
        } else if (customerType === 'corporate') {
            // Corporate gets special structure - using nett rates for now
            price = serviceType === 'shared' ? rates.nett : rates.nett * (rates.private / rates.shared);
        }

        // Apply return trip pricing - no discount, just double the one-way price
        if (tripType === 'return') {
            price *= 2.0; // Full double price for return
        }

        const formattedPrice = `$${price.toFixed(2)}`;
        const priceElement = document.getElementById('staff-price-display');
        console.log('Setting price to:', formattedPrice, 'Price element:', priceElement);

        if (priceElement) {
            priceElement.textContent = formattedPrice;
        } else {
            console.error('Price display element not found!');
        }
    }

    function clearForm() {
        form.reset();

        // Reset to defaults
        document.getElementById('staff-trip-type').value = 'one-way';
        document.getElementById('staff-customer-type').value = 'personal';
        document.getElementById('staff-passengers').value = '1';
        document.getElementById('staff-service-type').value = 'shared';
        departDateInput.value = today;

        // Hide conditional sections
        document.getElementById('staff-return-row').style.display = 'none';
        document.getElementById('staff-agent-row').style.display = 'none';
        document.getElementById('staff-travellers-group').style.display = 'none';

        // Reset price display
        document.getElementById('staff-price-display').textContent = 'Calculating...';

        // Focus phone field
        document.getElementById('staff-phone').focus();
    }

    function saveDraft() {
        const formData = new FormData(form);
        const draftData = Object.fromEntries(formData.entries());

        // Save to localStorage (in Phase 2, this would save to database)
        localStorage.setItem('staff-booking-draft', JSON.stringify(draftData));

        showMessage('Draft saved successfully! ✅', 'success');
    }

    function showMessage(message, type) {
        const existingMessage = document.querySelector('.success-message, .error-message');
        if (existingMessage) {
            existingMessage.remove();
        }

        const messageDiv = document.createElement('div');
        messageDiv.className = type === 'success' ? 'success-message' : 'error-message';
        messageDiv.textContent = message;

        form.insertBefore(messageDiv, form.firstChild);

        setTimeout(() => {
            messageDiv.remove();
        }, 3000);
    }

    // Form submission
    form.addEventListener('submit', function(e) {
        e.preventDefault();

        const formData = new FormData(form);
        const booking = {
            // Customer Information
            customerType: formData.get('customerType'),
            title: formData.get('title') || '',
            firstName: formData.get('firstName'),
            lastName: formData.get('lastName'),
            email: formData.get('email') || '',
            phone: formData.get('phone-lookup-field'),

            // Trip Details
            tripType: formData.get('tripType'),
            serviceType: formData.get('serviceType'),
            pickupLocation: formData.get('pickupLocation'),
            dropoffLocation: formData.get('dropoffLocation'),
            departDate: formData.get('departDate'),
            departTime: formData.get('departTime'),
            returnDate: formData.get('returnDate') || '',
            returnTime: formData.get('returnTime') || '',
            passengers: formData.get('passengers'),
            travellerNames: formData.get('travellerNames') || '',

            // Agent Information
            agent: formData.get('agent') || '',
            agentReference: formData.get('agentReference') || '',

            // Additional Information
            specialRequirements: formData.get('specialRequirements') || ''
        };

        if (validateStaffForm(booking)) {
            submitStaffBooking(booking);
        }
    });

    function validateStaffForm(booking) {
        const errors = [];

        // Check required fields
        if (!booking.firstName.trim()) errors.push('First name is required');
        if (!booking.lastName.trim()) errors.push('Last name is required');
        if (!booking.phone.trim()) errors.push('Phone number is required');
        if (!booking.tripType) errors.push('Trip type is required');
        if (!booking.pickupLocation) errors.push('Pickup location is required');
        if (!booking.dropoffLocation) errors.push('Drop-off location is required');
        if (!booking.departDate) errors.push('Departure date is required');
        if (!booking.departTime) errors.push('Departure time is required');
        if (!booking.passengers) errors.push('Number of passengers is required');

        // Check return trip requirements
        if (booking.tripType === 'return') {
            if (!booking.returnDate) errors.push('Return date is required');
            if (!booking.returnTime) errors.push('Return time is required');
        }

        if (errors.length > 0) {
            showMessage(`Errors: ${errors.join(', ')}`, 'error');
            return false;
        }

        return true;
    }

    function submitStaffBooking(booking) {
        // Show loading state
        const submitBtn = document.getElementById('create-booking-btn');
        const originalText = submitBtn.textContent;
        submitBtn.innerHTML = '<span class="spinner"></span> Creating...';
        submitBtn.disabled = true;

        // Simulate API call
        setTimeout(() => {
            const pnr = generatePNR();

            // Calculate final price
            const price = calculateFinalPrice(booking);

            // Create booking object for management system
            const managementBooking = {
                pnr: pnr,
                customerType: booking.customerType,
                title: booking.title,
                firstName: booking.firstName,
                lastName: booking.lastName,
                email: booking.email,
                phone: booking.phone,
                tripType: booking.tripType,
                serviceType: booking.serviceType,
                pickupLocation: booking.pickupLocation,
                dropoffLocation: booking.dropoffLocation,
                departDate: booking.departDate,
                departTime: booking.departTime,
                returnDate: booking.returnDate,
                returnTime: booking.returnTime,
                passengers: parseInt(booking.passengers),
                travellerNames: booking.travellerNames,
                agent: booking.agent,
                agentReference: booking.agentReference,
                specialRequirements: booking.specialRequirements,
                price: price,
                status: 'pending',
                driver: null,
                vehicle: null,
                created: new Date().toISOString()
            };

            // Save to management system
            saveToManagementSystem(managementBooking);

            showMessage(`✅ Booking ${pnr} created successfully!`, 'success');

            // Reset form
            clearForm();

            // Add to recent bookings (mock)
            addToRecentBookings(booking, pnr);

            // Reset button
            submitBtn.textContent = originalText;
            submitBtn.disabled = false;

            // Clear any saved draft
            localStorage.removeItem('staff-booking-draft');

            console.log('Staff booking submitted:', managementBooking);
        }, 1000);
    }

    function calculateFinalPrice(booking) {
        // Use the same calculation logic as the price display
        const tripType = booking.tripType;
        const pickup = booking.pickupLocation;
        const dropoff = booking.dropoffLocation;
        const passengers = parseInt(booking.passengers);
        const customerType = booking.customerType;
        const serviceType = booking.serviceType;

        // Determine which rate sheet to use and get destination
        let rateSheet, destination;
        if (pickup === 'kingscote-airport') {
            rateSheet = airportRates;
            destination = dropoff;
        } else if (dropoff === 'kingscote-airport') {
            rateSheet = airportRates;
            destination = pickup;
        } else if (pickup === 'kingscote-town') {
            rateSheet = kingscoteRates;
            destination = dropoff;
        } else if (dropoff === 'kingscote-town') {
            rateSheet = kingscoteRates;
            destination = pickup;
        } else if (pickup === 'penneshaw-ferry') {
            rateSheet = penneshawRates;
            destination = dropoff;
        } else if (dropoff === 'penneshaw-ferry') {
            rateSheet = penneshawRates;
            destination = pickup;
        } else {
            return 0; // Route not available
        }

        // Get passenger group
        let paxGroup = passengers;
        if (passengers > 6) paxGroup = 6;

        // Get rate for destination and passenger count
        const destinationRates = rateSheet[destination];
        if (!destinationRates) return 0;

        const rates = destinationRates[paxGroup];
        if (!rates) return 0;

        let price = 0;

        // Apply pricing based on customer type and service type
        if (customerType === 'personal') {
            price = serviceType === 'shared' ? rates.shared : rates.private;
        } else if (customerType === 'agent') {
            if (serviceType === 'shared') {
                price = rates.nett;
            } else {
                price = rates.nett * (rates.private / rates.shared);
            }
        } else if (customerType === 'corporate') {
            price = serviceType === 'shared' ? rates.nett : rates.nett * (rates.private / rates.shared);
        }

        // Apply return trip pricing
        if (tripType === 'return') {
            price *= 2.0;
        }

        return price;
    }

    function saveToManagementSystem(booking) {
        // Get existing bookings from management system
        const existingBookings = JSON.parse(localStorage.getItem('kit-bookings') || '[]');

        // Add new booking
        existingBookings.push(booking);

        // Save back to management system
        localStorage.setItem('kit-bookings', JSON.stringify(existingBookings));
    }

    function addToRecentBookings(booking, pnr) {
        const recentBookings = document.getElementById('recent-bookings');
        const newBooking = document.createElement('div');
        newBooking.className = 'booking-item';

        const pickupName = getLocationName(booking.pickupLocation);
        const dropoffName = getLocationName(booking.dropoffLocation);
        const customerName = `${booking.firstName} ${booking.lastName}`;
        const bookingTime = formatTime(booking.departTime);

        newBooking.innerHTML = `
            <div class="booking-pnr">${pnr}</div>
            <div class="booking-customer">${customerName}</div>
            <div class="booking-route">${pickupName} → ${dropoffName}</div>
            <div class="booking-date">Today ${bookingTime}</div>
            <div class="booking-status status-confirmed">Confirmed</div>
        `;

        recentBookings.insertBefore(newBooking, recentBookings.firstChild);

        // Remove last item if more than 5
        if (recentBookings.children.length > 5) {
            recentBookings.removeChild(recentBookings.lastChild);
        }
    }

    function generatePNR() {
        const prefix = 'KIT';
        const number = Math.floor(Math.random() * 9000) + 1000;
        return prefix + number;
    }

    function getLocationName(locationValue) {
        const locationMap = {
            'kingscote-airport': 'Airport',
            'penneshaw-ferry': 'Ferry',
            'kingscote-town': 'Town',
            'american-river': 'American River',
            'emu-bay': 'Emu Bay',
            'parndana': 'Parndana',
            'vivonne-bay': 'Vivonne Bay',
            'flinders-chase': 'Flinders Chase',
            'remarkable-rocks': 'Remarkable Rocks',
            'admirals-arch': 'Admirals Arch',
            'other': 'Other'
        };
        return locationMap[locationValue] || locationValue;
    }

    function formatTime(timeString) {
        const [hours, minutes] = timeString.split(':');
        const date = new Date();
        date.setHours(parseInt(hours), parseInt(minutes));
        return date.toLocaleTimeString('en-AU', {
            hour: 'numeric',
            minute: '2-digit',
            hour12: true
        });
    }

    // Load saved draft on page load
    const savedDraft = localStorage.getItem('staff-booking-draft');
    if (savedDraft) {
        const draftData = JSON.parse(savedDraft);
        Object.keys(draftData).forEach(key => {
            const field = form.querySelector(`[name="${key}"]`);
            if (field) {
                field.value = draftData[key];
            }
        });
        showMessage('Draft booking loaded ✨', 'success');
        calculatePrice();
    }

    // Initialize custom time pickers specifically for staff page
    function initializeStaffTimePickers() {
        console.log('Setting up time pickers...');

        // Remove any existing global click listeners to prevent duplicates
        document.removeEventListener('click', globalTimePickerHandler);

        const timePickers = document.querySelectorAll('.custom-time-picker');
        console.log('Found time pickers:', timePickers.length);

        timePickers.forEach(picker => {
            // Skip if already initialized
            if (picker.dataset.initialized === 'true') {
                return;
            }

            const displayInput = picker.querySelector('.time-display');
            const valueInput = picker.querySelector('.time-value');
            const popup = picker.querySelector('.time-popup');
            const hourOptions = picker.querySelectorAll('.hours-column .time-option');
            const minuteOptions = picker.querySelectorAll('.minutes-column .time-option');

            if (!displayInput || !valueInput || !popup) {
                console.error('Missing time picker elements:', { displayInput, valueInput, popup });
                return;
            }

            let selectedHour = '';
            let selectedMinute = '';

            // Handle display input click to show popup
            function handleDisplayClick(e) {
                e.preventDefault();
                console.log('Time picker clicked');
                closeAllStaffTimePickerPopups();

                // Check if this is a multi-transfer picker (needs fixed positioning)
                const isTransferPicker = picker.closest('.transfer-leg');
                const rect = displayInput.getBoundingClientRect();

                if (isTransferPicker) {
                    // Use fixed positioning for transfer pickers
                    popup.style.position = 'fixed';
                    popup.style.top = (rect.bottom + 5) + 'px';
                    popup.style.left = rect.left + 'px';
                    popup.style.zIndex = '99999';
                } else {
                    // Use regular positioning for main form picker
                    popup.style.position = 'absolute';
                    popup.style.top = (rect.bottom + window.scrollY + 2) + 'px';
                    popup.style.left = rect.left + 'px';
                }

                popup.classList.add('show');
                displayInput.focus();
            }

            // Handle display input focus
            function handleDisplayFocus() {
                console.log('Time picker focused');
                closeAllStaffTimePickerPopups();

                // Check if this is a multi-transfer picker (needs fixed positioning)
                const isTransferPicker = picker.closest('.transfer-leg');
                const rect = displayInput.getBoundingClientRect();

                if (isTransferPicker) {
                    // Use fixed positioning for transfer pickers
                    popup.style.position = 'fixed';
                    popup.style.top = (rect.bottom + 5) + 'px';
                    popup.style.left = rect.left + 'px';
                    popup.style.zIndex = '99999';
                } else {
                    // Use regular positioning for main form picker
                    popup.style.position = 'absolute';
                    popup.style.top = (rect.bottom + window.scrollY + 2) + 'px';
                    popup.style.left = rect.left + 'px';
                }

                popup.classList.add('show');
            }

            // Remove existing listeners if any
            displayInput.removeEventListener('click', handleDisplayClick);
            displayInput.removeEventListener('focus', handleDisplayFocus);

            // Add new listeners
            displayInput.addEventListener('click', handleDisplayClick);
            displayInput.addEventListener('focus', handleDisplayFocus);

            // Handle hour selection
            hourOptions.forEach(option => {
                option.addEventListener('click', function() {
                    console.log('Hour selected:', this.dataset.value);
                    selectedHour = this.dataset.value;

                    // Remove selected class from all hour options
                    hourOptions.forEach(opt => opt.classList.remove('selected'));
                    // Add selected class to clicked option
                    this.classList.add('selected');

                    updateTimeDisplay();
                });
            });

            // Handle minute selection
            minuteOptions.forEach(option => {
                option.addEventListener('click', function() {
                    console.log('Minute selected:', this.dataset.value);
                    selectedMinute = this.dataset.value;

                    // Remove selected class from all minute options
                    minuteOptions.forEach(opt => opt.classList.remove('selected'));
                    // Add selected class to clicked option
                    this.classList.add('selected');

                    updateTimeDisplay();
                });
            });

            function updateTimeDisplay() {
                if (selectedHour && selectedMinute) {
                    const hour = parseInt(selectedHour);
                    const minute = selectedMinute;
                    const period = hour >= 12 ? 'PM' : 'AM';
                    const displayHour = hour > 12 ? hour - 12 : (hour === 0 ? 12 : hour);

                    const timeString = `${displayHour}:${minute} ${period}`;
                    const valueString = `${selectedHour}:${minute}`;

                    displayInput.value = timeString;
                    valueInput.value = valueString;

                    console.log('Time updated:', timeString, valueString);

                    // Close popup after selection
                    setTimeout(() => {
                        popup.classList.remove('show');
                    }, 200);

                    // Trigger change event for form validation
                    const changeEvent = new Event('change', { bubbles: true });
                    valueInput.dispatchEvent(changeEvent);
                }
            }

            // Mark this picker as initialized
            picker.dataset.initialized = 'true';
        });

        // Set up global click handler
        globalTimePickerHandler = function(e) {
            if (!e.target.closest('.custom-time-picker')) {
                closeAllStaffTimePickerPopups();
            }
        };
        document.addEventListener('click', globalTimePickerHandler);

        function closeAllStaffTimePickerPopups() {
            const allPopups = document.querySelectorAll('.time-popup');
            allPopups.forEach(popup => popup.classList.remove('show'));
        }
    }

    // Global time picker click handler
    let globalTimePickerHandler = null;

    // Multi-Transfer Leg Management Functions
    let legCounter = 0;

    function addTransferLeg() {
        legCounter++;
        const container = document.getElementById('transfer-legs-container');

        const legHTML = `
            <div class="transfer-leg" data-leg-id="${legCounter}">
                <div class="leg-header">
                    <div class="leg-title">Transfer ${legCounter}</div>
                    <div class="leg-price-display" id="leg-${legCounter}-price">Select details</div>
                    <div class="leg-controls">
                        <button type="button" class="leg-btn toggle" onclick="toggleLeg(${legCounter})">▼ Hide</button>
                        <button type="button" class="leg-btn remove" onclick="removeLeg(${legCounter})">✕ Remove</button>
                    </div>
                </div>
                <div class="leg-content" data-leg-content="${legCounter}">
                    <div class="leg-row">
                        <div class="leg-group">
                            <label for="leg-${legCounter}-pickup">📍 Pickup</label>
                            <div class="location-input-container">
                                <select id="leg-${legCounter}-pickup-quick" class="location-quick-select">
                                    <option value="">🔥 Popular Locations</option>
                                    <option value="Kingscote Airport">Kingscote Airport</option>
                                    <option value="Penneshaw Ferry Terminal">Penneshaw Ferry Terminal</option>
                                    <option value="Ozone Hotel & Apartments">Ozone Hotel & Apartments</option>
                                    <option value="Sea Dragon Lodge">Sea Dragon Lodge</option>
                                    <option value="American River">American River</option>
                                    <option value="Mercure Kangaroo Island Lodge">Mercure Kangaroo Island Lodge</option>
                                    <option value="Remarkable Rocks">Remarkable Rocks</option>
                                    <option value="Flinders Chase National Park">Flinders Chase National Park</option>
                                    <option value="Emu Bay">Emu Bay</option>
                                    <option value="Vivonne Bay">Vivonne Bay</option>
                                </select>
                                <input type="text" id="leg-${legCounter}-pickup" name="leg[${legCounter}][pickup]"
                                       placeholder="🔍 Search or type any location..."
                                       class="location-autocomplete" required>
                                <div id="leg-${legCounter}-pickup-suggestions" class="autocomplete-suggestions"></div>
                            </div>
                        </div>
                        <div class="leg-group">
                            <label for="leg-${legCounter}-dropoff">🎯 Drop-off</label>
                            <div class="location-input-container">
                                <select id="leg-${legCounter}-dropoff-quick" class="location-quick-select">
                                    <option value="">🔥 Popular Locations</option>
                                    <option value="Kingscote Airport">Kingscote Airport</option>
                                    <option value="Penneshaw Ferry Terminal">Penneshaw Ferry Terminal</option>
                                    <option value="Ozone Hotel & Apartments">Ozone Hotel & Apartments</option>
                                    <option value="Sea Dragon Lodge">Sea Dragon Lodge</option>
                                    <option value="American River">American River</option>
                                    <option value="Mercure Kangaroo Island Lodge">Mercure Kangaroo Island Lodge</option>
                                    <option value="Remarkable Rocks">Remarkable Rocks</option>
                                    <option value="Flinders Chase National Park">Flinders Chase National Park</option>
                                    <option value="Emu Bay">Emu Bay</option>
                                    <option value="Vivonne Bay">Vivonne Bay</option>
                                </select>
                                <input type="text" id="leg-${legCounter}-dropoff" name="leg[${legCounter}][dropoff]"
                                       placeholder="🔍 Search or type any location..."
                                       class="location-autocomplete" required>
                                <div id="leg-${legCounter}-dropoff-suggestions" class="autocomplete-suggestions"></div>
                            </div>
                        </div>
                        <div class="leg-group">
                            <label for="leg-${legCounter}-date">📅 Date</label>
                            <input type="date" id="leg-${legCounter}-date" name="leg[${legCounter}][date]" required>
                        </div>
                        <div class="leg-group">
                            <label for="leg-${legCounter}-time">🕐 Time</label>
                            <div class="custom-time-picker" data-name="leg[${legCounter}][time]" data-required="true">
                                <input type="text" class="time-display" readonly placeholder="Select time" required>
                                <input type="hidden" class="time-value" name="leg[${legCounter}][time]">
                                <div class="time-popup">
                                    <div class="time-selector">
                                        <div class="time-column hours-column">
                                            <div class="time-header">Hour</div>
                                            <div class="time-options">
                                                <div class="time-option" data-value="06">6 AM</div>
                                                <div class="time-option" data-value="07">7 AM</div>
                                                <div class="time-option" data-value="08">8 AM</div>
                                                <div class="time-option" data-value="09">9 AM</div>
                                                <div class="time-option" data-value="10">10 AM</div>
                                                <div class="time-option" data-value="11">11 AM</div>
                                                <div class="time-option" data-value="12">12 PM</div>
                                                <div class="time-option" data-value="13">1 PM</div>
                                                <div class="time-option" data-value="14">2 PM</div>
                                                <div class="time-option" data-value="15">3 PM</div>
                                                <div class="time-option" data-value="16">4 PM</div>
                                                <div class="time-option" data-value="17">5 PM</div>
                                                <div class="time-option" data-value="18">6 PM</div>
                                                <div class="time-option" data-value="19">7 PM</div>
                                                <div class="time-option" data-value="20">8 PM</div>
                                                <div class="time-option" data-value="21">9 PM</div>
                                                <div class="time-option" data-value="22">10 PM</div>
                                            </div>
                                        </div>
                                        <div class="time-column minutes-column">
                                            <div class="time-header">Minutes</div>
                                            <div class="time-options">
                                                <div class="time-option" data-value="00">00</div>
                                                <div class="time-option" data-value="05">05</div>
                                                <div class="time-option" data-value="10">10</div>
                                                <div class="time-option" data-value="15">15</div>
                                                <div class="time-option" data-value="20">20</div>
                                                <div class="time-option" data-value="25">25</div>
                                                <div class="time-option" data-value="30">30</div>
                                                <div class="time-option" data-value="35">35</div>
                                                <div class="time-option" data-value="40">40</div>
                                                <div class="time-option" data-value="45">45</div>
                                                <div class="time-option" data-value="50">50</div>
                                                <div class="time-option" data-value="55">55</div>
                                            </div>
                                        </div>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                    <div class="leg-summary" id="leg-${legCounter}-summary">
                        Complete leg details to see pricing
                    </div>
                </div>
            </div>
        `;

        container.insertAdjacentHTML('beforeend', legHTML);

        // Reinitialize all time pickers to include the new one
        setTimeout(() => {
            initializeStaffTimePickers();
        }, 100);

        // Add event listeners for the new leg
        addLegEventListeners(legCounter);

        // Update total summary
        updateMultiTransferSummary();
    }

    function removeLeg(legId) {
        const leg = document.querySelector(`.transfer-leg[data-leg-id="${legId}"]`);
        if (leg) {
            leg.remove();
            updateMultiTransferSummary();

            // Don't allow removing if only one transfer remains
            const remainingLegs = document.querySelectorAll('.transfer-leg');
            if (remainingLegs.length === 1) {
                const removeBtn = remainingLegs[0].querySelector('.leg-btn.remove');
                if (removeBtn) {
                    removeBtn.disabled = true;
                    removeBtn.textContent = '✕ Keep';
                    removeBtn.style.opacity = '0.5';
                }
            }
        }
    }

    function toggleLeg(legId) {
        const content = document.querySelector(`[data-leg-content="${legId}"]`);
        const toggleBtn = content.parentElement.querySelector('.leg-btn.toggle');

        if (content.classList.contains('collapsed')) {
            content.classList.remove('collapsed');
            toggleBtn.textContent = '▼ Hide';
        } else {
            content.classList.add('collapsed');
            toggleBtn.textContent = '▶ Show';
        }
    }

    function addLegEventListeners(legId) {
        console.log(`Adding event listeners for transfer ${legId}`);

        // Initialize auto-complete for this transfer leg
        setupLocationInput(`leg-${legId}-pickup`, `leg-${legId}-pickup-quick`, `leg-${legId}-pickup-suggestions`);
        setupLocationInput(`leg-${legId}-dropoff`, `leg-${legId}-dropoff-quick`, `leg-${legId}-dropoff-suggestions`);

        const pickupSelect = document.getElementById(`leg-${legId}-pickup`);
        const dropoffSelect = document.getElementById(`leg-${legId}-dropoff`);
        const dateInput = document.getElementById(`leg-${legId}-date`);
        const timeInput = document.querySelector(`[data-name="leg[${legId}][time]"] .time-value`);

        console.log(`Transfer ${legId} elements found:`, {
            pickup: !!pickupSelect,
            dropoff: !!dropoffSelect,
            date: !!dateInput,
            time: !!timeInput
        });

        // Set minimum date
        const today = new Date().toISOString().split('T')[0];
        if (dateInput) {
            dateInput.setAttribute('min', today);
        }

        // Add change listeners
        [pickupSelect, dropoffSelect, dateInput, timeInput].forEach((input, index) => {
            if (input) {
                const inputTypes = ['pickup', 'dropoff', 'date', 'time'];
                input.addEventListener('change', async () => {
                    console.log(`Transfer ${legId} ${inputTypes[index]} changed to:`, input.value);


                    await updateLegSummary(legId);
                    updateMultiTransferSummary();
                });
            } else {
                console.error(`Missing input for transfer ${legId}:`, inputTypes[index]);
            }
        });

    }

    async function updateLegSummary(legId) {
        console.log(`updateLegSummary called for legId: ${legId}`);

        const pickupEl = document.getElementById(`leg-${legId}-pickup`);
        const dropoffEl = document.getElementById(`leg-${legId}-dropoff`);
        const dateEl = document.getElementById(`leg-${legId}-date`);
        const timeValueEl = document.querySelector(`[data-name="leg[${legId}][time]"] .time-value`);
        const timeDisplayEl = document.querySelector(`[data-name="leg[${legId}][time]"] .time-display`);
        const summaryDiv = document.getElementById(`leg-${legId}-summary`);

        if (!pickupEl || !dropoffEl || !dateEl || !timeValueEl || !timeDisplayEl || !summaryDiv) {
            console.error(`Missing elements for leg ${legId}:`, {
                pickup: !!pickupEl,
                dropoff: !!dropoffEl,
                date: !!dateEl,
                timeValue: !!timeValueEl,
                timeDisplay: !!timeDisplayEl,
                summary: !!summaryDiv
            });
            return;
        }

        const pickup = pickupEl.value;
        const dropoff = dropoffEl.value;
        const date = dateEl.value;
        const timeValue = timeValueEl.value;
        const timeDisplay = timeDisplayEl.value;

        if (pickup && dropoff && date && timeValue) {
            console.log(`Transfer ${legId} has all required fields`);
            const pickupText = getLocationDisplayName(pickup);
            const dropoffText = getLocationDisplayName(dropoff);
            const passengers = parseInt(document.getElementById('staff-passengers').value) || 1;
            const serviceType = document.getElementById('staff-service-type').value;
            const customerType = document.getElementById('staff-customer-type').value;

            console.log(`Transfer ${legId} pricing inputs:`, { pickup, dropoff, passengers, serviceType, customerType });

            // Calculate price for this leg
            const price = await calculateLegPrice(pickup, dropoff, passengers, serviceType, customerType);
            console.log(`Transfer ${legId} calculated price: $${price}`);

            // Check if minimum passenger warning applies
            const isAirportKingscote =
                (pickup === 'kingscote-airport' && dropoff === 'kingscote-town') ||
                (pickup === 'kingscote-town' && dropoff === 'kingscote-airport');
            const showMinWarning = passengers === 1 && !isAirportKingscote;

            // Update header price display
            const headerPriceDisplay = document.getElementById(`leg-${legId}-price`);
            if (headerPriceDisplay) {
                headerPriceDisplay.textContent = `$${price.toFixed(2)}${showMinWarning ? ' (min 2)' : ''}`;
            }

            // Get address information if available
            const pickupAddress = document.getElementById(`leg-${legId}-pickup-address`)?.value || '';
            const dropoffAddress = document.getElementById(`leg-${legId}-dropoff-address`)?.value || '';

            let pickupDisplay = pickupText;
            let dropoffDisplay = dropoffText;

            if (pickupAddress) {
                pickupDisplay += ` (${pickupAddress})`;
            }
            if (dropoffAddress) {
                dropoffDisplay += ` (${dropoffAddress})`;
            }

            summaryDiv.innerHTML = `
                <strong>${pickupDisplay} → ${dropoffDisplay}</strong><br>
                📅 ${formatDate(date)} at ${timeDisplay}<br>
                👥 ${passengers} passenger${passengers > 1 ? 's' : ''} (${serviceType})${showMinWarning ? '<br><span style="color: #e67e22; font-weight: 600;">⚠️ Minimum 2 passengers - charged for 2</span>' : ''}<br>
                <span class="leg-price">$${price.toFixed(2)}</span>
            `;
        } else {
            // Update header price display for incomplete legs
            const headerPriceDisplay = document.getElementById(`leg-${legId}-price`);
            if (headerPriceDisplay) {
                headerPriceDisplay.textContent = 'Select details';
            }

            summaryDiv.innerHTML = 'Complete leg details to see pricing';
        }
    }

    function getLocationDisplayName(value) {
        // If it's already a readable name (contains spaces or uppercase), return as-is
        if (/[A-Z\s]/.test(value)) {
            return value;
        }

        // Otherwise map location codes to display names
        const locationMap = {
            'kingscote-airport': 'Kingscote Airport',
            'penneshaw-ferry': 'Penneshaw Ferry',
            'kingscote-town': 'Kingscote Town',
            'american-river': 'American River',
            'emu-bay': 'Emu Bay',
            'parndana': 'Parndana',
            'vivonne-bay': 'Vivonne Bay',
            'flinders-chase': 'Flinders Chase NP',
            'flinders-chase-visitor-centre': 'Flinders Chase NP Visitor Info Centre',
            'remarkable-rocks': 'Remarkable Rocks',
            'admirals-arch': 'Admirals Arch',
            'other': 'Other'
        };
        return locationMap[value] || value;
    }

    async function calculateLegPrice(pickup, dropoff, passengers, serviceType, customerType) {
        // Use the same pricing logic as the main calculatePrice function
        return await calculatePriceForRoute(pickup, dropoff, passengers, serviceType, customerType, 'one-way');
    }

    async function calculatePriceForRoute(pickup, dropoff, passengers, serviceType, customerType, tripType) {
        console.log(`calculatePriceForRoute called:`, { pickup, dropoff, passengers, serviceType, customerType, tripType });

        if (!pickup || !dropoff || !passengers || !serviceType) {
            console.log('Missing required parameters');
            return 0;
        }

        // Convert accommodation/location names to pricing codes
        const pickupCode = await getLocationCodeForPricing(pickup);
        const dropoffCode = await getLocationCodeForPricing(dropoff);

        console.log(`Location mapping: ${pickup} -> ${pickupCode}, ${dropoff} -> ${dropoffCode}`);

        // Support all common destination combinations
        const supportedLocations = [
            'kingscote-airport', 'kingscote-town', 'penneshaw-ferry',
            'american-river', 'emu-bay', 'parndana', 'vivonne-bay',
            'flinders-chase', 'flinders-chase-visitor-centre', 'remarkable-rocks', 'admirals-arch'
        ];

        if (!supportedLocations.includes(pickupCode) || !supportedLocations.includes(dropoffCode)) {
            console.log('Route not supported - unsupported location:', { pickupCode, dropoffCode });
            return 0;
        }

        // Rate sheet data (2025-2026 rates)
        const airportRates = {
            'kingscote-town': { // Kingscote
                1: { shared: 45.00, nett: 36.00, private: 72.00 },
                2: { shared: 90.00, nett: 72.00, private: 144.00 },
                3: { shared: 110.00, nett: 88.00, private: 176.00 },
                4: { shared: 130.00, nett: 104.00, private: 208.00 },
                5: { shared: 150.00, nett: 120.00, private: 240.00 },
                6: { shared: 170.00, nett: 136.00, private: 272.00 }
            },
            'american-river': {
                2: { shared: 105.00, nett: 84.00, private: 126.00 },
                3: { shared: 125.00, nett: 100.00, private: 150.00 },
                4: { shared: 145.00, nett: 116.00, private: 174.00 },
                5: { shared: 165.00, nett: 132.00, private: 198.00 },
                6: { shared: 185.00, nett: 148.00, private: 222.00 }
            },
            'penneshaw-ferry': { // Penneshaw
                2: { shared: 182.00, nett: 145.60, private: 218.40 },
                3: { shared: 202.00, nett: 161.60, private: 242.40 },
                4: { shared: 222.00, nett: 177.60, private: 266.40 },
                5: { shared: 242.00, nett: 193.60, private: 290.40 },
                6: { shared: 262.00, nett: 209.60, private: 314.40 }
            },
            'vivonne-bay': {
                2: { shared: 168.00, nett: 134.40, private: 201.60 },
                3: { shared: 188.00, nett: 150.40, private: 225.60 },
                4: { shared: 208.00, nett: 166.40, private: 249.60 },
                5: { shared: 228.00, nett: 182.40, private: 273.60 },
                6: { shared: 248.00, nett: 198.40, private: 297.60 }
            },
            'flinders-chase': { // Represents Southern Ocean Lodge area
                2: { shared: 315.00, nett: 252.00, private: 378.00 },
                3: { shared: 335.00, nett: 268.00, private: 402.00 },
                4: { shared: 355.00, nett: 284.00, private: 426.00 },
                5: { shared: 375.00, nett: 300.00, private: 450.00 },
                6: { shared: 395.00, nett: 316.00, private: 474.00 }
            },
            'flinders-chase-visitor-centre': {
                2: { shared: 300.00, nett: 240.00, private: 360.00 },
                3: { shared: 320.00, nett: 256.00, private: 384.00 },
                4: { shared: 340.00, nett: 272.00, private: 408.00 },
                5: { shared: 360.00, nett: 288.00, private: 432.00 },
                6: { shared: 380.00, nett: 304.00, private: 456.00 }
            },
            'emu-bay': {
                2: { shared: 94.50, nett: 75.60, private: 113.40 },
                3: { shared: 114.50, nett: 91.60, private: 137.40 },
                4: { shared: 134.50, nett: 107.60, private: 161.40 },
                5: { shared: 154.50, nett: 123.60, private: 185.40 },
                6: { shared: 174.50, nett: 139.60, private: 209.40 }
            },
            'parndana': {
                2: { shared: 133.00, nett: 106.40, private: 159.60 },
                3: { shared: 153.00, nett: 122.40, private: 183.60 },
                4: { shared: 173.00, nett: 138.40, private: 207.60 },
                5: { shared: 193.00, nett: 154.40, private: 231.60 },
                6: { shared: 213.00, nett: 170.40, private: 255.60 }
            }
        };

        // Kingscote to other destinations rates
        const kingscoteRates = {
            'kingscote-airport': { // Kingscote to Airport
                1: { shared: 36.00, nett: 28.80, private: 57.60 },
                2: { shared: 72.00, nett: 57.60, private: 115.20 },
                3: { shared: 92.00, nett: 73.60, private: 147.20 },
                4: { shared: 112.00, nett: 89.60, private: 179.20 },
                5: { shared: 132.00, nett: 105.60, private: 211.20 },
                6: { shared: 152.00, nett: 121.60, private: 243.20 }
            },
            'american-river': {
                2: { shared: 138.60, nett: 110.88, private: 166.32 },
                3: { shared: 158.60, nett: 126.88, private: 190.32 },
                4: { shared: 178.60, nett: 142.88, private: 214.32 },
                5: { shared: 198.60, nett: 158.88, private: 238.32 },
                6: { shared: 218.60, nett: 174.88, private: 262.32 }
            },
            'penneshaw-ferry': {
                2: { shared: 198.00, nett: 158.40, private: 237.60 },
                3: { shared: 218.00, nett: 174.40, private: 261.60 },
                4: { shared: 238.00, nett: 190.40, private: 285.60 },
                5: { shared: 258.00, nett: 206.40, private: 309.60 },
                6: { shared: 278.00, nett: 222.40, private: 333.60 }
            }
        };

        // Penneshaw to other destinations rates
        const penneshawRates = {
            'kingscote-town': {
                2: { shared: 198.00, nett: 158.40, private: 237.60 },
                3: { shared: 218.00, nett: 174.40, private: 261.60 },
                4: { shared: 238.00, nett: 190.40, private: 285.60 },
                5: { shared: 258.00, nett: 206.40, private: 309.60 },
                6: { shared: 278.00, nett: 222.40, private: 333.60 }
            },
            'kingscote-airport': {
                2: { shared: 182.00, nett: 145.60, private: 218.40 },
                3: { shared: 202.00, nett: 161.60, private: 242.40 },
                4: { shared: 222.00, nett: 177.60, private: 266.40 },
                5: { shared: 242.00, nett: 193.60, private: 290.40 },
                6: { shared: 262.00, nett: 209.60, private: 314.40 }
            },
            'parndana': {
                2: { shared: 168.00, nett: 134.40, private: 201.60 },
                3: { shared: 188.00, nett: 150.40, private: 225.60 },
                4: { shared: 208.00, nett: 166.40, private: 249.60 },
                5: { shared: 228.00, nett: 182.40, private: 273.60 },
                6: { shared: 248.00, nett: 198.40, private: 297.60 }
            },
            'american-river': {
                2: { shared: 158.00, nett: 126.40, private: 189.60 },
                3: { shared: 178.00, nett: 142.40, private: 213.60 },
                4: { shared: 198.00, nett: 158.40, private: 237.60 },
                5: { shared: 218.00, nett: 174.40, private: 261.60 },
                6: { shared: 238.00, nett: 190.40, private: 285.60 }
            },
            'emu-bay': {
                2: { shared: 148.00, nett: 118.40, private: 177.60 },
                3: { shared: 168.00, nett: 134.40, private: 201.60 },
                4: { shared: 188.00, nett: 150.40, private: 225.60 },
                5: { shared: 208.00, nett: 166.40, private: 249.60 },
                6: { shared: 228.00, nett: 182.40, private: 273.60 }
            },
            'vivonne-bay': {
                2: { shared: 138.00, nett: 110.40, private: 165.60 },
                3: { shared: 158.00, nett: 126.40, private: 189.60 },
                4: { shared: 178.00, nett: 142.40, private: 213.60 },
                5: { shared: 198.00, nett: 158.40, private: 237.60 },
                6: { shared: 218.00, nett: 174.40, private: 261.60 }
            }
        };

        // American River to other destinations rates
        const americanRiverRates = {
            'emu-bay': {
                2: { shared: 105.00, nett: 84.00, private: 126.00 },
                3: { shared: 125.00, nett: 100.00, private: 150.00 },
                4: { shared: 145.00, nett: 116.00, private: 174.00 },
                5: { shared: 165.00, nett: 132.00, private: 198.00 },
                6: { shared: 185.00, nett: 148.00, private: 222.00 }
            },
            'parndana': {
                2: { shared: 120.00, nett: 96.00, private: 144.00 },
                3: { shared: 140.00, nett: 112.00, private: 168.00 },
                4: { shared: 160.00, nett: 128.00, private: 192.00 },
                5: { shared: 180.00, nett: 144.00, private: 216.00 },
                6: { shared: 200.00, nett: 160.00, private: 240.00 }
            },
            'remarkable-rocks': {
                2: { shared: 280.00, nett: 224.00, private: 336.00 },
                3: { shared: 300.00, nett: 240.00, private: 360.00 },
                4: { shared: 320.00, nett: 256.00, private: 384.00 },
                5: { shared: 340.00, nett: 272.00, private: 408.00 },
                6: { shared: 360.00, nett: 288.00, private: 432.00 }
            },
            'admirals-arch': {
                2: { shared: 285.00, nett: 228.00, private: 342.00 },
                3: { shared: 305.00, nett: 244.00, private: 366.00 },
                4: { shared: 325.00, nett: 260.00, private: 390.00 },
                5: { shared: 345.00, nett: 276.00, private: 414.00 },
                6: { shared: 365.00, nett: 292.00, private: 438.00 }
            },
            'flinders-chase': {
                2: { shared: 275.00, nett: 220.00, private: 330.00 },
                3: { shared: 295.00, nett: 236.00, private: 354.00 },
                4: { shared: 315.00, nett: 252.00, private: 378.00 },
                5: { shared: 335.00, nett: 268.00, private: 402.00 },
                6: { shared: 355.00, nett: 284.00, private: 426.00 }
            }
        };

        // Emu Bay to other destinations rates
        const emuBayRates = {
            'american-river': {
                2: { shared: 105.00, nett: 84.00, private: 126.00 },
                3: { shared: 125.00, nett: 100.00, private: 150.00 },
                4: { shared: 145.00, nett: 116.00, private: 174.00 },
                5: { shared: 165.00, nett: 132.00, private: 198.00 },
                6: { shared: 185.00, nett: 148.00, private: 222.00 }
            },
            'parndana': {
                2: { shared: 98.00, nett: 78.40, private: 117.60 },
                3: { shared: 118.00, nett: 94.40, private: 141.60 },
                4: { shared: 138.00, nett: 110.40, private: 165.60 },
                5: { shared: 158.00, nett: 126.40, private: 189.60 },
                6: { shared: 178.00, nett: 142.40, private: 213.60 }
            },
            'remarkable-rocks': {
                2: { shared: 270.00, nett: 216.00, private: 324.00 },
                3: { shared: 290.00, nett: 232.00, private: 348.00 },
                4: { shared: 310.00, nett: 248.00, private: 372.00 },
                5: { shared: 330.00, nett: 264.00, private: 396.00 },
                6: { shared: 350.00, nett: 280.00, private: 420.00 }
            },
            'admirals-arch': {
                2: { shared: 275.00, nett: 220.00, private: 330.00 },
                3: { shared: 295.00, nett: 236.00, private: 354.00 },
                4: { shared: 315.00, nett: 252.00, private: 378.00 },
                5: { shared: 335.00, nett: 268.00, private: 402.00 },
                6: { shared: 355.00, nett: 284.00, private: 426.00 }
            }
        };

        // Parndana to other destinations rates
        const parndanaRates = {
            'american-river': {
                2: { shared: 120.00, nett: 96.00, private: 144.00 },
                3: { shared: 140.00, nett: 112.00, private: 168.00 },
                4: { shared: 160.00, nett: 128.00, private: 192.00 },
                5: { shared: 180.00, nett: 144.00, private: 216.00 },
                6: { shared: 200.00, nett: 160.00, private: 240.00 }
            },
            'emu-bay': {
                2: { shared: 98.00, nett: 78.40, private: 117.60 },
                3: { shared: 118.00, nett: 94.40, private: 141.60 },
                4: { shared: 138.00, nett: 110.40, private: 165.60 },
                5: { shared: 158.00, nett: 126.40, private: 189.60 },
                6: { shared: 178.00, nett: 142.40, private: 213.60 }
            }
        };

        // Remarkable Rocks to other destinations rates
        const remarkableRocksRates = {
            'american-river': {
                2: { shared: 280.00, nett: 224.00, private: 336.00 },
                3: { shared: 300.00, nett: 240.00, private: 360.00 },
                4: { shared: 320.00, nett: 256.00, private: 384.00 },
                5: { shared: 340.00, nett: 272.00, private: 408.00 },
                6: { shared: 360.00, nett: 288.00, private: 432.00 }
            },
            'emu-bay': {
                2: { shared: 270.00, nett: 216.00, private: 324.00 },
                3: { shared: 290.00, nett: 232.00, private: 348.00 },
                4: { shared: 310.00, nett: 248.00, private: 372.00 },
                5: { shared: 330.00, nett: 264.00, private: 396.00 },
                6: { shared: 350.00, nett: 280.00, private: 420.00 }
            }
        };

        // Admirals Arch to other destinations rates
        const admiralsArchRates = {
            'american-river': {
                2: { shared: 285.00, nett: 228.00, private: 342.00 },
                3: { shared: 305.00, nett: 244.00, private: 366.00 },
                4: { shared: 325.00, nett: 260.00, private: 390.00 },
                5: { shared: 345.00, nett: 276.00, private: 414.00 },
                6: { shared: 365.00, nett: 292.00, private: 438.00 }
            },
            'emu-bay': {
                2: { shared: 275.00, nett: 220.00, private: 330.00 },
                3: { shared: 295.00, nett: 236.00, private: 354.00 },
                4: { shared: 315.00, nett: 252.00, private: 378.00 },
                5: { shared: 335.00, nett: 268.00, private: 402.00 },
                6: { shared: 355.00, nett: 284.00, private: 426.00 }
            }
        };

        let destinationRates = null;

        // Determine the destination rates based on mapped pickup/dropoff codes
        if (pickupCode === 'kingscote-airport') {
            console.log(`Using airport rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = airportRates[dropoffCode];
            console.log(`Found airport rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'kingscote-airport') {
            console.log(`Using airport rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = airportRates[pickupCode];
            console.log(`Found airport rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'kingscote-town') {
            console.log(`Using kingscote rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = kingscoteRates[dropoffCode];
            console.log(`Found kingscote rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'kingscote-town') {
            console.log(`Using kingscote rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = kingscoteRates[pickupCode];
            console.log(`Found kingscote rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'penneshaw-ferry') {
            console.log(`Using penneshaw rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = penneshawRates[dropoffCode];
            console.log(`Found penneshaw rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'penneshaw-ferry') {
            console.log(`Using penneshaw rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = penneshawRates[pickupCode];
            console.log(`Found penneshaw rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'american-river') {
            console.log(`Using american river rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = americanRiverRates[dropoffCode];
            console.log(`Found american river rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'american-river') {
            console.log(`Using american river rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = americanRiverRates[pickupCode];
            console.log(`Found american river rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'emu-bay') {
            console.log(`Using emu bay rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = emuBayRates[dropoffCode];
            console.log(`Found emu bay rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'emu-bay') {
            console.log(`Using emu bay rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = emuBayRates[pickupCode];
            console.log(`Found emu bay rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'parndana') {
            console.log(`Using parndana rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = parndanaRates[dropoffCode];
            console.log(`Found parndana rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'parndana') {
            console.log(`Using parndana rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = parndanaRates[pickupCode];
            console.log(`Found parndana rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'remarkable-rocks') {
            console.log(`Using remarkable rocks rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = remarkableRocksRates[dropoffCode];
            console.log(`Found remarkable rocks rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'remarkable-rocks') {
            console.log(`Using remarkable rocks rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = remarkableRocksRates[pickupCode];
            console.log(`Found remarkable rocks rates for ${pickupCode}:`, !!destinationRates);
        } else if (pickupCode === 'admirals-arch') {
            console.log(`Using admirals arch rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = admiralsArchRates[dropoffCode];
            console.log(`Found admirals arch rates for ${dropoffCode}:`, !!destinationRates);
        } else if (dropoffCode === 'admirals-arch') {
            console.log(`Using admirals arch rates for pickup: ${pickupCode}, dropoff: ${dropoffCode}`);
            destinationRates = admiralsArchRates[pickupCode];
            console.log(`Found admirals arch rates for ${pickupCode}:`, !!destinationRates);
        }

        if (!destinationRates) {
            console.log(`No destination rates found for route: ${pickup} → ${dropoff} (mapped: ${pickupCode} → ${dropoffCode})`);
            return 0;
        }

        // Handle passenger minimum rules
        let paxGroup = passengers > 6 ? 6 : passengers;
        let isMinimumPaxWarning = false;

        // Check if this is Airport ↔ Kingscote (only route that allows 1 passenger)
        const isAirportKingscote =
            (pickup === 'kingscote-airport' && dropoff === 'kingscote-town') ||
            (pickup === 'kingscote-town' && dropoff === 'kingscote-airport');

        // For 1 passenger on non-Airport↔Kingscote routes, use 2-passenger pricing
        if (passengers === 1 && !isAirportKingscote) {
            console.log(`Warning: 1 passenger on ${pickup} → ${dropoff} route - using 2-passenger pricing`);
            paxGroup = 2;
            isMinimumPaxWarning = true;
        }

        console.log(`Passenger group: ${paxGroup} for ${passengers} passengers${isMinimumPaxWarning ? ' (minimum 2 pax rule applied)' : ''}`);
        const rates = destinationRates[paxGroup];
        console.log(`Found rates for passenger group ${paxGroup}:`, !!rates);
        if (!rates) {
            console.log(`No rates found for passenger group ${paxGroup}. Available groups:`, Object.keys(destinationRates));
            return 0;
        }

        let price = 0;

        // Apply pricing based on customer type and service type
        if (customerType === 'personal') {
            // Personal customers get shared RRP or private RRP
            price = serviceType === 'shared' ? rates.shared : rates.private;
        } else if (customerType === 'agent') {
            // Agents get nett price (shared nett or private calculated from nett)
            if (serviceType === 'shared') {
                price = rates.nett;
            } else {
                // Private nett = shared nett * (private RRP / shared RRP)
                price = rates.nett * (rates.private / rates.shared);
            }
        } else if (customerType === 'corporate') {
            // Corporate gets special structure - using nett rates for now
            price = serviceType === 'shared' ? rates.nett : rates.nett * (rates.private / rates.shared);
        }

        // Apply return trip pricing - no discount, just double the one-way price
        if (tripType === 'return') {
            price *= 2.0; // Full double price for return
        }

        console.log(`Final calculated price: $${price} for ${pickup} → ${dropoff}`);
        return price;
    }

    async function updateAllTransferPricing() {
        console.log('updateAllTransferPricing called');
        const legs = document.querySelectorAll('.transfer-leg');
        console.log('Found transfer legs:', legs.length);

        for (const [index, leg] of legs.entries()) {
            const legId = leg.dataset.legId;
            console.log(`Updating transfer ${index + 1}, legId: ${legId}`);

            // Check if all required fields exist for this leg
            const pickup = document.getElementById(`leg-${legId}-pickup`);
            const dropoff = document.getElementById(`leg-${legId}-dropoff`);
            const date = document.getElementById(`leg-${legId}-date`);
            const timeValue = document.querySelector(`[data-name="leg[${legId}][time]"] .time-value`);

            console.log(`Transfer ${legId} elements:`, {
                pickup: pickup ? pickup.value : 'missing',
                dropoff: dropoff ? dropoff.value : 'missing',
                date: date ? date.value : 'missing',
                time: timeValue ? timeValue.value : 'missing'
            });

            await updateLegSummary(legId);
        }
        updateMultiTransferSummary();
    }

    function updateMultiTransferSummary() {
        console.log('updateMultiTransferSummary called');
        const legs = document.querySelectorAll('.transfer-leg');
        console.log('Found legs:', legs.length);
        let totalPrice = 0;
        let completedLegs = 0;

        // Check if we need to create the add button section
        let addButtonSection = document.querySelector('.add-transfer-bottom');
        if (!addButtonSection && legs.length > 0) {
            const multiTransferSection = document.getElementById('staff-multi-transfer-section');
            addButtonSection = document.createElement('div');
            addButtonSection.className = 'add-transfer-bottom';
            addButtonSection.innerHTML = '<button type="button" class="btn-secondary" onclick="addTransferLeg()">+ Add Transfer</button>';
            multiTransferSection.appendChild(addButtonSection);
        }

        // Check if we need to create the summary section
        let summarySection = document.querySelector('.total-legs-summary');
        if (!summarySection && legs.length > 0) {
            console.log('Creating summary section');
            const multiTransferSection = document.getElementById('staff-multi-transfer-section');
            if (multiTransferSection) {
                summarySection = document.createElement('div');
                summarySection.className = 'total-legs-summary';
                multiTransferSection.appendChild(summarySection);
                console.log('Summary section created and appended');
            } else {
                console.error('Could not find staff-multi-transfer-section');
            }
        }

        if (summarySection && legs.length > 0) {
            console.log('Updating summary content');
            let summaryHTML = '<h4>📋 Multi-Transfer Summary</h4><div class="legs-breakdown">';

            legs.forEach((leg, index) => {
                const legId = leg.dataset.legId;
                const pickup = document.getElementById(`leg-${legId}-pickup`).value;
                const dropoff = document.getElementById(`leg-${legId}-dropoff`).value;
                const date = document.getElementById(`leg-${legId}-date`).value;
                const timeValue = document.querySelector(`[data-name="leg[${legId}][time]"] .time-value`).value;

                if (pickup && dropoff && date && timeValue) {
                    const passengers = parseInt(document.getElementById('staff-passengers').value) || 1;
                    const serviceType = document.getElementById('staff-service-type').value;
                    const customerType = document.getElementById('staff-customer-type').value;
                    const price = calculateLegPrice(pickup, dropoff, passengers, serviceType, customerType);

                    totalPrice += price;
                    completedLegs++;

                    summaryHTML += `
                        <div class="leg-breakdown-item">
                            <span>Transfer ${parseInt(legId)}: ${getLocationDisplayName(pickup)} → ${getLocationDisplayName(dropoff)}</span>
                            <span>$${price.toFixed(2)}</span>
                        </div>
                    `;
                } else {
                    summaryHTML += `
                        <div class="leg-breakdown-item">
                            <span>Transfer ${parseInt(legId)}: <em>Incomplete</em></span>
                            <span>-</span>
                        </div>
                    `;
                }
            });

            summaryHTML += `
                <div class="total-price-row">
                    <span>Total (${completedLegs}/${legs.length} transfers):</span>
                    <span>$${totalPrice.toFixed(2)}</span>
                </div>
            </div>`;

            summarySection.innerHTML = summaryHTML;
        }

        // Update main price display
        const priceDisplay = document.getElementById('staff-price-display');
        if (priceDisplay && legs.length > 0) {
            if (completedLegs === legs.length && legs.length > 0) {
                priceDisplay.textContent = `$${totalPrice.toFixed(2)} (${legs.length} transfers)`;
            } else {
                priceDisplay.textContent = `$${totalPrice.toFixed(2)} (${completedLegs}/${legs.length} transfers)`;
            }
        }
    }

    function formatDate(dateString) {
        const date = new Date(dateString);
        return date.toLocaleDateString('en-AU', {
            weekday: 'short',
            day: 'numeric',
            month: 'short'
        });
    }


    // Location Auto-Complete System

    // Google Places API integration
    let placesService = null;
    let autocompleteService = null;

    function initializeGooglePlaces() {
        if (typeof google !== 'undefined' && google.maps && google.maps.places) {
            autocompleteService = new google.maps.places.AutocompleteService();

            // Create a hidden map for PlacesService
            const mapDiv = document.createElement('div');
            mapDiv.style.display = 'none';
            document.body.appendChild(mapDiv);

            const map = new google.maps.Map(mapDiv, {
                center: { lat: -35.6555, lng: 137.6447 }, // Kingscote center
                zoom: 13
            });

            placesService = new google.maps.places.PlacesService(map);
            console.log('Google Places API initialized');
        } else {
            console.log('Google Places API not available - using local data only');
        }
    }

    // Geographic bounds for Kangaroo Island
    const KI_BOUNDS = {
        north: -35.4,
        south: -36.2,
        east: 138.0,
        west: 136.6
    };

    // Town/suburb boundaries for more precise mapping
    const KI_GEOGRAPHIC_ZONES = {
        kingscote: { center: { lat: -35.6555, lng: 137.6447 }, radius: 8 }, // 8km radius
        americanRiver: { center: { lat: -35.7744, lng: 137.7661 }, radius: 5 },
        penneshaw: { center: { lat: -35.7167, lng: 137.9333 }, radius: 4 },
        parndana: { center: { lat: -35.7833, lng: 137.2667 }, radius: 6 },
        emuBay: { center: { lat: -35.6167, lng: 137.3833 }, radius: 3 },
        vivonneBay: { center: { lat: -35.9167, lng: 137.1833 }, radius: 4 },
        flindersChase: { center: { lat: -36.0667, lng: 136.9167 }, radius: 15 }
    };

    function getDistanceFromPoint(lat1, lng1, lat2, lng2) {
        const R = 6371; // Earth's radius in kilometers
        const dLat = (lat2 - lat1) * Math.PI / 180;
        const dLng = (lng2 - lng1) * Math.PI / 180;
        const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
                Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
                Math.sin(dLng/2) * Math.sin(dLng/2);
        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
        return R * c;
    }

    function determineKIZoneFromCoordinates(lat, lng) {
        // Check if coordinates are within Kangaroo Island bounds
        if (lat < KI_BOUNDS.south || lat > KI_BOUNDS.north ||
            lng < KI_BOUNDS.west || lng > KI_BOUNDS.east) {
            return null; // Not on Kangaroo Island
        }

        let closestZone = null;
        let closestDistance = Infinity;

        for (const [zoneName, zone] of Object.entries(KI_GEOGRAPHIC_ZONES)) {
            const distance = getDistanceFromPoint(lat, lng, zone.center.lat, zone.center.lng);
            if (distance <= zone.radius && distance < closestDistance) {
                closestDistance = distance;
                closestZone = zoneName;
            }
        }

        // Map zone names to pricing codes
        const zoneMapping = {
            kingscote: 'kingscote-town',
            americanRiver: 'american-river',
            penneshaw: 'penneshaw-ferry',
            parndana: 'parndana',
            emuBay: 'emu-bay',
            vivonneBay: 'vivonne-bay',
            flindersChase: 'flinders-chase'
        };

        return closestZone ? zoneMapping[closestZone] : 'kingscote-town'; // Default to Kingscote
    }

    async function getLocationDetailsFromGoogle(locationName) {
        return new Promise((resolve) => {
            if (!placesService) {
                resolve(null);
                return;
            }

            const request = {
                query: locationName + ', Kangaroo Island, South Australia',
                fields: ['name', 'geometry', 'formatted_address', 'place_id']
            };

            placesService.textSearch(request, (results, status) => {
                if (status === google.maps.places.PlacesServiceStatus.OK && results.length > 0) {
                    const place = results[0];
                    const location = place.geometry.location;
                    const zoneCode = determineKIZoneFromCoordinates(location.lat(), location.lng());

                    resolve({
                        name: place.name,
                        formatted_address: place.formatted_address,
                        location: {
                            lat: location.lat(),
                            lng: location.lng()
                        },
                        zone_code: zoneCode,
                        place_id: place.place_id
                    });
                } else {
                    resolve(null);
                }
            });
        });
    }

    async function getGooglePlacePredictions(input) {
        return new Promise((resolve) => {
            if (!autocompleteService) {
                resolve([]);
                return;
            }

            const request = {
                input: input,
                componentRestrictions: { country: 'au' },
                bounds: new google.maps.LatLngBounds(
                    new google.maps.LatLng(KI_BOUNDS.south, KI_BOUNDS.west),
                    new google.maps.LatLng(KI_BOUNDS.north, KI_BOUNDS.east)
                ),
                types: ['establishment', 'geocode']
            };

            autocompleteService.getPlacePredictions(request, (predictions, status) => {
                if (status === google.maps.places.PlacesServiceStatus.OK) {
                    // Filter for Kangaroo Island locations
                    const kiPredictions = predictions.filter(prediction =>
                        prediction.description.toLowerCase().includes('kangaroo island') ||
                        prediction.description.toLowerCase().includes('kingscote') ||
                        prediction.description.toLowerCase().includes('american river') ||
                        prediction.description.toLowerCase().includes('penneshaw') ||
                        prediction.description.toLowerCase().includes('parndana') ||
                        prediction.description.toLowerCase().includes('emu bay') ||
                        prediction.description.toLowerCase().includes('vivonne bay')
                    );
                    resolve(kiPredictions);
                } else {
                    resolve([]);
                }
            });
        });
    }

    // Enhanced accommodation to pricing location mapping
    async function getLocationCodeForPricing(locationName) {
        // First check static mappings for known accommodations
        const locationMappings = {
            // Kingscote accommodations - use 'kingscote-town' for pricing
            "Ozone Hotel & Apartments": "kingscote-town",
            "Aurora Ozone Hotel & Apartments": "kingscote-town",
            "Mercure KI Lodge (KIL)": "kingscote-town",
            "Mercure Kangaroo Island Lodge": "kingscote-town",
            "Seaview Motel": "kingscote-town",
            "Kangaroo Island Cabins": "kingscote-town",
            "Kingscote Town": "kingscote-town",
            "9 Torrens St, Kingscote": "kingscote-town",
            "4 Todd St, Kingscote": "kingscote-town",
            "23 Cygnet Road, Kingscote": "kingscote-town",
            "15 Wheelton St, Kingscote": "kingscote-town",
            "17 Dutton St, Kingscote": "kingscote-town",
            "5 Kohinoor Rd, Kingscote": "kingscote-town",
            "Chapel St, Kingscote": "kingscote-town",
            "Dauncey St, Kingscote": "kingscote-town",

            // American River accommodations - use 'american-river' for pricing
            "The River Suites, American River": "american-river",
            "American River": "american-river",

            // Penneshaw accommodations - use 'penneshaw-ferry' for pricing
            "Seafront Resort, Penneshaw": "penneshaw-ferry",
            "Seaside Inn": "penneshaw-ferry",
            "Penneshaw": "penneshaw-ferry",
            "Penneshaw Ferry": "penneshaw-ferry",
            "Penneshaw Ferry Terminal": "penneshaw-ferry",
            "Penneshaw Wharf": "penneshaw-ferry",

            // Vivonne Bay accommodations - use 'vivonne-bay' for pricing
            "Villas on the Bay": "vivonne-bay",
            "Oceanview Eco Villas (OEV)": "vivonne-bay",
            "Vivonne Bay": "vivonne-bay",

            // Emu Bay accommodations - use 'emu-bay' for pricing
            "Emu Bay": "emu-bay",

            // Parndana accommodations - use 'parndana' for pricing
            "Parndana": "parndana",

            // Flinders Chase area - use 'flinders-chase' for pricing
            "Southern Ocean Lodge (SOL)": "flinders-chase",
            "Stranraer Homestead": "flinders-chase",
            "Sea Dragon Lodge": "flinders-chase",
            "Wanderers Rest": "flinders-chase",
            "Flinders Chase National Park": "flinders-chase",
            "Flinders Chase NP Visitor Info Centre": "flinders-chase-visitor-centre",

            // Remarkable Rocks & Admirals Arch
            "Remarkable Rocks": "remarkable-rocks",
            "Admirals Arch": "admirals-arch",

            // Airport
            "Kingscote Airport": "kingscote-airport",

            // Other locations - map to closest town
            "Providence Guest House": "kingscote-town", // Assume Kingscote area
            "Wickham House": "kingscote-town", // Assume Kingscote area
            "Coastal Breeze Holiday Units": "kingscote-town", // Assume Kingscote area
            "Cygnet River": "kingscote-town", // Close to Kingscote
            "Stokes Bay": "parndana", // Closer to Parndana
            "Island Beach": "american-river", // Close to American River
            "Browns Beach": "emu-bay", // Close to Emu Bay
            "Brownlow": "parndana", // Interior location
            "Dudley East": "american-river", // Eastern peninsula

            // Attractions that don't have specific rates - map to closest location
            "Seal Bay Conservation Park": "vivonne-bay",
            "Kelly Hill Conservation Park": "flinders-chase",
            "Little Sahara": "vivonne-bay",
            "Emu Ridge Eucalyptus Distillery": "parndana",
            "Kangaroo Island Wildlife Park": "american-river",
            "Rapture Park": "american-river",

            // Services - map to Kingscote (main town)
            "Hospital": "kingscote-town",
            "KI Medical Centre, Murray St": "kingscote-town",
            "KI Health Service (KIHS)": "kingscote-town",
            "Drakes Supermarket, Commercial St": "kingscote-town",
            "OTR - Kingscote": "kingscote-town",
            "KI Council, Dauncey St": "kingscote-town",

            // Wineries - map to closest towns
            "Islander Estate Winery": "american-river",
            "Bay of Shoals Winery": "american-river",
            "KIS (Kangaroo Island Spirits)": "parndana",
            "False Cape Wines": "american-river"
        };

        // Check if it's a known accommodation/location
        if (locationMappings[locationName]) {
            return locationMappings[locationName];
        }

        // For custom addresses, try Google Places API
        try {
            const googleResult = await getLocationDetailsFromGoogle(locationName);
            if (googleResult && googleResult.zone_code) {
                console.log(`Google Places mapped "${locationName}" to zone: ${googleResult.zone_code}`);
                return googleResult.zone_code;
            }
        } catch (error) {
            console.log('Google Places API error:', error);
        }

        // Fallback: try to detect location from text patterns
        const locationLower = locationName.toLowerCase();

        // Check for street addresses with town names
        if (locationLower.includes('kingscote') ||
            locationLower.includes('commercial') || locationLower.includes('dauncey') ||
            locationLower.includes('torrens') || locationLower.includes('chapman') ||
            locationLower.includes('murray') || locationLower.includes('telegraph')) {
            return 'kingscote-town';
        }
        if (locationLower.includes('american river')) {
            return 'american-river';
        }
        if (locationLower.includes('penneshaw')) {
            return 'penneshaw-ferry';
        }
        if (locationLower.includes('parndana')) {
            return 'parndana';
        }
        if (locationLower.includes('emu bay')) {
            return 'emu-bay';
        }
        if (locationLower.includes('vivonne bay')) {
            return 'vivonne-bay';
        }

        // Default fallback - assume Kingscote (main town)
        console.log(`No mapping found for "${locationName}", defaulting to kingscote-town`);
        return 'kingscote-town';
    }

    const allKangarooIslandLocations = [
        // Airports & Transport
        { name: "Kingscote Airport", type: "Transport", keywords: ["airport", "kingscote"] },
        { name: "Penneshaw Ferry", type: "Transport", keywords: ["ferry", "penneshaw", "sealink"] },
        { name: "Penneshaw Wharf", type: "Transport", keywords: ["wharf", "penneshaw", "ferry"] },

        // Major Accommodations (from Knack data)
        { name: "Ozone Hotel & Apartments", type: "Hotel", keywords: ["ozone", "hotel", "kingscote"] },
        { name: "Mercure KI Lodge (KIL)", type: "Hotel", keywords: ["mercure", "lodge", "kil"] },
        { name: "Sea Dragon Lodge", type: "Lodge", keywords: ["sea", "dragon", "lodge"] },
        { name: "Southern Ocean Lodge (SOL)", type: "Luxury Lodge", keywords: ["southern", "ocean", "lodge", "sol", "luxury"] },
        { name: "The River Suites, American River", type: "Suites", keywords: ["river", "suites", "american"] },
        { name: "Seafront Resort, Penneshaw", type: "Resort", keywords: ["seafront", "resort", "penneshaw"] },
        { name: "Seaside Inn", type: "Inn", keywords: ["seaside", "inn"] },
        { name: "Stranraer Homestead", type: "Homestead", keywords: ["stranraer", "homestead"] },
        { name: "Villas on the Bay", type: "Villas", keywords: ["villas", "bay"] },
        { name: "Oceanview Eco Villas (OEV)", type: "Eco Villas", keywords: ["oceanview", "eco", "villas", "oev"] },
        { name: "Providence Guest House", type: "Guest House", keywords: ["providence", "guest", "house"] },
        { name: "Wickham House", type: "Guest House", keywords: ["wickham", "house"] },
        { name: "Wanderers Rest", type: "Guest House", keywords: ["wanderers", "rest"] },
        { name: "Seaview Motel", type: "Motel", keywords: ["seaview", "motel"] },
        { name: "Coastal Breeze Holiday Units", type: "Holiday Units", keywords: ["coastal", "breeze", "holiday", "units"] },
        { name: "Kangaroo Island Cabins", type: "Cabins", keywords: ["cabins", "accommodation"] },

        // Towns & Areas
        { name: "Kingscote Town", type: "Town", keywords: ["kingscote", "town", "main"] },
        { name: "American River", type: "Town", keywords: ["american", "river"] },
        { name: "Emu Bay", type: "Town", keywords: ["emu", "bay"] },
        { name: "Parndana", type: "Town", keywords: ["parndana"] },
        { name: "Vivonne Bay", type: "Town", keywords: ["vivonne", "bay"] },
        { name: "Penneshaw", type: "Town", keywords: ["penneshaw"] },
        { name: "Cygnet River", type: "Town", keywords: ["cygnet", "river"] },
        { name: "Stokes Bay", type: "Town", keywords: ["stokes", "bay"] },
        { name: "Island Beach", type: "Area", keywords: ["island", "beach"] },
        { name: "Browns Beach", type: "Area", keywords: ["browns", "beach"] },
        { name: "Brownlow", type: "Area", keywords: ["brownlow"] },
        { name: "Dudley East", type: "Area", keywords: ["dudley", "east"] },

        // Attractions & National Parks
        { name: "Flinders Chase National Park", type: "National Park", keywords: ["flinders", "chase", "national", "park"] },
        { name: "Flinders Chase NP Visitor Info Centre", type: "Visitor Centre", keywords: ["flinders", "visitor", "centre", "info"] },
        { name: "Remarkable Rocks", type: "Attraction", keywords: ["remarkable", "rocks"] },
        { name: "Admirals Arch", type: "Attraction", keywords: ["admirals", "arch"] },
        { name: "Seal Bay Conservation Park", type: "Conservation Park", keywords: ["seal", "bay", "conservation"] },
        { name: "Kelly Hill Conservation Park", type: "Conservation Park", keywords: ["kelly", "hill", "caves"] },
        { name: "Little Sahara", type: "Attraction", keywords: ["little", "sahara", "sand", "dunes"] },
        { name: "Emu Ridge Eucalyptus Distillery", type: "Attraction", keywords: ["emu", "ridge", "eucalyptus", "distillery"] },
        { name: "Kangaroo Island Wildlife Park", type: "Wildlife Park", keywords: ["wildlife", "park", "animals"] },
        { name: "Rapture Park", type: "Attraction", keywords: ["rapture", "park"] },

        // Medical & Services
        { name: "Hospital", type: "Medical", keywords: ["hospital", "medical", "health"] },
        { name: "KI Medical Centre, Murray St", type: "Medical", keywords: ["medical", "centre", "murray", "doctor"] },
        { name: "KI Health Service (KIHS)", type: "Medical", keywords: ["health", "service", "kihs"] },

        // Wineries & Food
        { name: "Islander Estate Winery", type: "Winery", keywords: ["islander", "estate", "winery", "wine"] },
        { name: "Bay of Shoals Winery", type: "Winery", keywords: ["bay", "shoals", "winery", "wine"] },
        { name: "KIS (Kangaroo Island Spirits)", type: "Distillery", keywords: ["kis", "spirits", "distillery"] },
        { name: "False Cape Wines", type: "Winery", keywords: ["false", "cape", "wines"] },

        // Business & Shopping
        { name: "Drakes Supermarket, Commercial St", type: "Shopping", keywords: ["drakes", "supermarket", "shopping"] },
        { name: "OTR - Kingscote", type: "Fuel/Convenience", keywords: ["otr", "fuel", "convenience"] },
        { name: "KI Council, Dauncey St", type: "Government", keywords: ["council", "government", "dauncey"] },

        // Specific Addresses (from Knack data patterns)
        { name: "9 Torrens St, Kingscote", type: "Address", keywords: ["torrens", "street", "kingscote"] },
        { name: "4 Todd St, Kingscote", type: "Address", keywords: ["todd", "street", "kingscote"] },
        { name: "23 Cygnet Road, Kingscote", type: "Address", keywords: ["cygnet", "road", "kingscote"] },
        { name: "15 Wheelton St, Kingscote", type: "Address", keywords: ["wheelton", "street", "kingscote"] },
        { name: "17 Dutton St, Kingscote", type: "Address", keywords: ["dutton", "street", "kingscote"] },
        { name: "5 Kohinoor Rd, Kingscote", type: "Address", keywords: ["kohinoor", "road", "kingscote"] },
        { name: "Brownlow Road", type: "Address", keywords: ["brownlow", "road"] },
        { name: "Chapel St, Kingscote", type: "Address", keywords: ["chapel", "street", "kingscote"] },
        { name: "Dauncey St, Kingscote", type: "Address", keywords: ["dauncey", "street", "kingscote"] }
    ];

    function initializeLocationAutocomplete() {
        // Initialize pickup location autocomplete
        setupLocationInput('staff-pickup', 'staff-pickup-quick', 'staff-pickup-suggestions');

        // Initialize dropoff location autocomplete
        setupLocationInput('staff-dropoff', 'staff-dropoff-quick', 'staff-dropoff-suggestions');
    }

    function setupLocationInput(inputId, quickSelectId, suggestionsId) {
        const input = document.getElementById(inputId);
        const quickSelect = document.getElementById(quickSelectId);
        const suggestions = document.getElementById(suggestionsId);

        if (!input || !quickSelect || !suggestions) return;

        // Handle quick select dropdown
        quickSelect.addEventListener('change', function() {
            if (this.value) {
                input.value = this.value;
                input.focus();
                hideSuggestions(suggestions);

                // Trigger price calculation
                calculatePrice();
                updateAllTransferPricing();
            }
        });

        // Handle autocomplete input
        input.addEventListener('input', function() {
            const query = this.value.trim();
            if (query.length >= 2) {
                showSuggestions(query, suggestions, input);
            } else {
                hideSuggestions(suggestions);
            }
        });

        // Handle keyboard navigation
        input.addEventListener('keydown', function(e) {
            handleKeyboardNavigation(e, suggestions, input);
        });

        // Hide suggestions when clicking outside
        document.addEventListener('click', function(e) {
            if (!input.contains(e.target) && !suggestions.contains(e.target)) {
                hideSuggestions(suggestions);
            }
        });

        // Trigger price calculation when selection is made
        input.addEventListener('change', function() {
            calculatePrice();
            updateAllTransferPricing();
        });

        // Add scroll and resize listeners to reposition suggestions
        window.addEventListener('scroll', function() {
            repositionSuggestions(suggestions, input);
        });

        window.addEventListener('resize', function() {
            repositionSuggestions(suggestions, input);
        });

        // Hide suggestions when input loses focus (with delay for clicking)
        input.addEventListener('blur', function() {
            setTimeout(() => {
                hideSuggestions(suggestions);
            }, 150);
        });
    }

    async function showSuggestions(query, suggestionsContainer, input) {
        // Get local matches first
        const localMatches = searchLocations(query);

        // Get Google Places predictions
        let googleMatches = [];
        try {
            const googlePredictions = await getGooglePlacePredictions(query);
            googleMatches = googlePredictions.map(prediction => ({
                name: prediction.description,
                type: 'Address',
                isGooglePlace: true,
                place_id: prediction.place_id
            }));
        } catch (error) {
            console.log('Google Places prediction error:', error);
        }

        // Combine results (local first, then Google)
        const allMatches = [...localMatches, ...googleMatches];

        if (allMatches.length === 0) {
            hideSuggestions(suggestionsContainer);
            return;
        }

        suggestionsContainer.innerHTML = '';

        // Add local matches
        localMatches.forEach((location, index) => {
            const div = document.createElement('div');
            div.className = 'autocomplete-suggestion';
            div.innerHTML = `
                ${location.name}
                <span class="location-type">${location.type}</span>
            `;

            div.addEventListener('click', function() {
                input.value = location.name;
                hideSuggestions(suggestionsContainer);
                input.focus();
                calculatePrice();
                updateAllTransferPricing();
            });

            suggestionsContainer.appendChild(div);
        });

        // Add separator if we have both local and Google results
        if (localMatches.length > 0 && googleMatches.length > 0) {
            const separator = document.createElement('div');
            separator.className = 'autocomplete-separator';
            separator.innerHTML = '<span>📍 Street Addresses</span>';
            suggestionsContainer.appendChild(separator);
        }

        // Add Google Places matches
        googleMatches.slice(0, 5).forEach((location, index) => { // Limit to 5 Google results
            const div = document.createElement('div');
            div.className = 'autocomplete-suggestion google-place';
            div.innerHTML = `
                ${location.name}
                <span class="location-type google-icon">📍 ${location.type}</span>
            `;

            div.addEventListener('click', function() {
                input.value = location.name;
                hideSuggestions(suggestionsContainer);
                input.focus();
                calculatePrice();
                updateAllTransferPricing();
            });

            suggestionsContainer.appendChild(div);
        });

        // Position the suggestions box relative to the input field
        const inputRect = input.getBoundingClientRect();
        suggestionsContainer.style.left = inputRect.left + 'px';
        suggestionsContainer.style.top = (inputRect.bottom) + 'px';
        suggestionsContainer.style.width = Math.max(inputRect.width, 250) + 'px';

        suggestionsContainer.style.display = 'block';
    }

    function hideSuggestions(suggestionsContainer) {
        suggestionsContainer.style.display = 'none';
    }

    function repositionSuggestions(suggestionsContainer, input) {
        if (suggestionsContainer.style.display === 'block') {
            const inputRect = input.getBoundingClientRect();
            suggestionsContainer.style.left = inputRect.left + 'px';
            suggestionsContainer.style.top = (inputRect.bottom) + 'px';
            suggestionsContainer.style.width = Math.max(inputRect.width, 250) + 'px';
        }
    }

    function searchLocations(query) {
        const queryLower = query.toLowerCase();
        const matches = [];

        allKangarooIslandLocations.forEach(location => {
            const nameMatch = location.name.toLowerCase().includes(queryLower);
            const keywordMatch = location.keywords.some(keyword =>
                keyword.toLowerCase().includes(queryLower)
            );

            if (nameMatch || keywordMatch) {
                matches.push(location);
            }
        });

        // Sort by relevance - exact matches first, then partial matches
        return matches.sort((a, b) => {
            const aExact = a.name.toLowerCase().startsWith(queryLower);
            const bExact = b.name.toLowerCase().startsWith(queryLower);

            if (aExact && !bExact) return -1;
            if (!aExact && bExact) return 1;

            return a.name.localeCompare(b.name);
        }).slice(0, 8); // Limit to 8 suggestions
    }

    function handleKeyboardNavigation(e, suggestionsContainer, input) {
        const suggestions = suggestionsContainer.querySelectorAll('.autocomplete-suggestion');
        let highlighted = suggestionsContainer.querySelector('.highlighted');

        if (e.key === 'ArrowDown') {
            e.preventDefault();
            if (!highlighted) {
                suggestions[0]?.classList.add('highlighted');
            } else {
                highlighted.classList.remove('highlighted');
                const next = highlighted.nextElementSibling || suggestions[0];
                next.classList.add('highlighted');
            }
        } else if (e.key === 'ArrowUp') {
            e.preventDefault();
            if (!highlighted) {
                suggestions[suggestions.length - 1]?.classList.add('highlighted');
            } else {
                highlighted.classList.remove('highlighted');
                const prev = highlighted.previousElementSibling || suggestions[suggestions.length - 1];
                prev.classList.add('highlighted');
            }
        } else if (e.key === 'Enter') {
            e.preventDefault();
            if (highlighted) {
                input.value = highlighted.textContent.split('\n')[0].trim();
                hideSuggestions(suggestionsContainer);
                calculatePrice();
                updateAllTransferPricing();
            }
        } else if (e.key === 'Escape') {
            hideSuggestions(suggestionsContainer);
        }
    }

    // Address field management
    function updateAddressFields() {
        const pickup = document.getElementById('staff-pickup').value;
        const dropoff = document.getElementById('staff-dropoff').value;

        const pickupAddressRow = document.getElementById('staff-pickup-address-row');
        const dropoffAddressRow = document.getElementById('staff-dropoff-address-row');

        // Destinations that need address fields (towns and accommodations)
        const destinationsNeedingAddress = [
            'kingscote-town', 'american-river', 'emu-bay', 'parndana', 'vivonne-bay', 'penneshaw-ferry'
        ];

        // Show pickup address if needed
        if (destinationsNeedingAddress.includes(pickup)) {
            pickupAddressRow.style.display = 'block';
        } else {
            pickupAddressRow.style.display = 'none';
            // Reset accommodation dropdown and address field
            const pickupAccommodation = document.getElementById('staff-pickup-accommodation');
            const pickupCustom = document.getElementById('staff-pickup-custom-address');
            const pickupAddress = document.getElementById('staff-pickup-address');
            if (pickupAccommodation) pickupAccommodation.value = '';
            if (pickupCustom) pickupCustom.style.display = 'none';
            if (pickupAddress) pickupAddress.value = '';
        }

        // Show dropoff address if needed
        if (destinationsNeedingAddress.includes(dropoff)) {
            dropoffAddressRow.style.display = 'block';
        } else {
            dropoffAddressRow.style.display = 'none';
            // Reset accommodation dropdown and address field
            const dropoffAccommodation = document.getElementById('staff-dropoff-accommodation');
            const dropoffCustom = document.getElementById('staff-dropoff-custom-address');
            const dropoffAddress = document.getElementById('staff-dropoff-address');
            if (dropoffAccommodation) dropoffAccommodation.value = '';
            if (dropoffCustom) dropoffCustom.style.display = 'none';
            if (dropoffAddress) dropoffAddress.value = '';
        }
    }

    // Handle accommodation dropdown changes
    function handleAccommodationChange(type) {
        const accommodationSelect = document.getElementById(`staff-${type}-accommodation`);
        const customAddressDiv = document.getElementById(`staff-${type}-custom-address`);
        const addressInput = document.getElementById(`staff-${type}-address`);

        if (!accommodationSelect || !customAddressDiv || !addressInput) return;

        if (accommodationSelect.value === 'custom') {
            customAddressDiv.style.display = 'block';
            addressInput.required = true;
        } else {
            customAddressDiv.style.display = 'none';
            addressInput.required = false;
            addressInput.value = '';
        }
    }

    function updateTransferAddressFields(legId) {
        const pickup = document.getElementById(`leg-${legId}-pickup`).value;
        const dropoff = document.getElementById(`leg-${legId}-dropoff`).value;

        const addressesDiv = document.getElementById(`leg-${legId}-addresses`);

        // Destinations that need address fields
        const destinationsNeedingAddress = [
            'kingscote-town', 'american-river', 'emu-bay', 'parndana', 'vivonne-bay', 'penneshaw-ferry'
        ];

        // Show address fields if either pickup or dropoff needs them
        if (destinationsNeedingAddress.includes(pickup) || destinationsNeedingAddress.includes(dropoff)) {
            addressesDiv.style.display = 'grid';

            // Update pickup fields
            const pickupAccommodationGroup = document.querySelector(`#leg-${legId}-addresses .leg-group:nth-child(1)`);
            const pickupCustomGroup = document.querySelector(`#leg-${legId}-addresses .leg-group:nth-child(2)`);

            if (destinationsNeedingAddress.includes(pickup)) {
                pickupAccommodationGroup.style.display = 'block';
                // Check if custom is selected
                const pickupAccommodation = document.getElementById(`leg-${legId}-pickup-accommodation`);
                if (pickupAccommodation && pickupAccommodation.value === 'custom') {
                    pickupCustomGroup.style.display = 'block';
                } else {
                    pickupCustomGroup.style.display = 'none';
                }
            } else {
                pickupAccommodationGroup.style.display = 'none';
                pickupCustomGroup.style.display = 'none';
                // Reset values
                const pickupAccommodation = document.getElementById(`leg-${legId}-pickup-accommodation`);
                const pickupAddress = document.getElementById(`leg-${legId}-pickup-address`);
                if (pickupAccommodation) pickupAccommodation.value = '';
                if (pickupAddress) pickupAddress.value = '';
            }

            // Update dropoff fields
            const dropoffAccommodationGroup = document.querySelector(`#leg-${legId}-addresses .leg-group:nth-child(3)`);
            const dropoffCustomGroup = document.querySelector(`#leg-${legId}-addresses .leg-group:nth-child(4)`);

            if (destinationsNeedingAddress.includes(dropoff)) {
                dropoffAccommodationGroup.style.display = 'block';
                // Check if custom is selected
                const dropoffAccommodation = document.getElementById(`leg-${legId}-dropoff-accommodation`);
                if (dropoffAccommodation && dropoffAccommodation.value === 'custom') {
                    dropoffCustomGroup.style.display = 'block';
                } else {
                    dropoffCustomGroup.style.display = 'none';
                }
            } else {
                dropoffAccommodationGroup.style.display = 'none';
                dropoffCustomGroup.style.display = 'none';
                // Reset values
                const dropoffAccommodation = document.getElementById(`leg-${legId}-dropoff-accommodation`);
                const dropoffAddress = document.getElementById(`leg-${legId}-dropoff-address`);
                if (dropoffAccommodation) dropoffAccommodation.value = '';
                if (dropoffAddress) dropoffAddress.value = '';
            }
        } else {
            addressesDiv.style.display = 'none';
            // Reset all values
            const pickupAccommodation = document.getElementById(`leg-${legId}-pickup-accommodation`);
            const pickupAddress = document.getElementById(`leg-${legId}-pickup-address`);
            const dropoffAccommodation = document.getElementById(`leg-${legId}-dropoff-accommodation`);
            const dropoffAddress = document.getElementById(`leg-${legId}-dropoff-address`);
            if (pickupAccommodation) pickupAccommodation.value = '';
            if (pickupAddress) pickupAddress.value = '';
            if (dropoffAccommodation) dropoffAccommodation.value = '';
            if (dropoffAddress) dropoffAddress.value = '';
        }
    }

    // Handle multi-transfer accommodation dropdown changes
    function handleTransferAccommodationChange(legId, type) {
        const accommodationSelect = document.getElementById(`leg-${legId}-${type}-accommodation`);
        const customGroup = document.getElementById(`leg-${legId}-${type}-custom`);
        const addressInput = document.getElementById(`leg-${legId}-${type}-address`);

        if (!accommodationSelect || !customGroup || !addressInput) return;

        if (accommodationSelect.value === 'custom') {
            customGroup.style.display = 'block';
            addressInput.required = true;
        } else {
            customGroup.style.display = 'none';
            addressInput.required = false;
            addressInput.value = '';
        }
    }

    // Make functions globally available
    window.addTransferLeg = addTransferLeg;
    window.removeLeg = removeLeg;
    window.toggleLeg = toggleLeg;
    window.updateAddressFields = updateAddressFields;
    window.updateTransferAddressFields = updateTransferAddressFields;
});