/**
 * Bluetooth Mode Controller
 * Uses the new unified Bluetooth API at /api/bluetooth/
 */

const BluetoothMode = (function() {
    'use strict';

    // State
    let isScanning = false;
    let eventSource = null;
    let agentPollTimer = null;  // Polling fallback for agent mode
    let devices = new Map();
    let baselineSet = false;
    let baselineCount = 0;

    // DOM elements (cached)
    let startBtn, stopBtn, messageContainer, deviceContainer;
    let adapterSelect, scanModeSelect, transportSelect, durationInput, minRssiInput;
    let baselineStatusEl, capabilityStatusEl;

    // Stats tracking
    let deviceStats = {
        strong: 0,
        medium: 0,
        weak: 0,
        trackers: []
    };

    // Zone counts for proximity display
    let zoneCounts = { immediate: 0, near: 0, far: 0 };

    // New visualization components
    let radarInitialized = false;
    let radarPaused = false;

    // Device list filter
    let currentDeviceFilter = 'all';
    let currentSearchTerm = '';
    let visibleDeviceCount = 0;
    let pendingDeviceFlush = false;
    let selectedDeviceNeedsRefresh = false;
    let filterListenersBound = false;
    let listListenersBound = false;
    const pendingDeviceIds = new Set();

    // Agent support
    let showAllAgentsMode = false;
    let lastAgentId = null;

    /**
     * Get API base URL, routing through agent proxy if agent is selected.
     */
    function getApiBase() {
        if (typeof currentAgent !== 'undefined' && currentAgent !== 'local') {
            return `/controller/agents/${currentAgent}`;
        }
        return '';
    }

    /**
     * Get current agent name for tagging data.
     */
    function getCurrentAgentName() {
        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
            return 'Local';
        }
        if (typeof agents !== 'undefined') {
            const agent = agents.find(a => a.id == currentAgent);
            return agent ? agent.name : `Agent ${currentAgent}`;
        }
        return `Agent ${currentAgent}`;
    }

    /**
     * Check for agent mode conflicts before starting scan.
     */
    async function checkAgentConflicts() {
        if (typeof currentAgent === 'undefined' || currentAgent === 'local') {
            return true;
        }
        if (typeof checkAgentModeConflict === 'function') {
            return await checkAgentModeConflict('bluetooth');
        }
        return true;
    }

    /**
     * Initialize the Bluetooth mode
     */
    function init() {
        console.log('[BT] Initializing BluetoothMode');

        // Cache DOM elements
        startBtn = document.getElementById('startBtBtn');
        stopBtn = document.getElementById('stopBtBtn');
        messageContainer = document.getElementById('btMessageContainer');
        deviceContainer = document.getElementById('btDeviceListContent');
        adapterSelect = document.getElementById('btAdapterSelect');
        scanModeSelect = document.getElementById('btScanMode');
        transportSelect = document.getElementById('btTransport');
        durationInput = document.getElementById('btScanDuration');
        minRssiInput = document.getElementById('btMinRssi');
        baselineStatusEl = document.getElementById('btBaselineStatus');
        capabilityStatusEl = document.getElementById('btCapabilityStatus');

        // Check capabilities on load
        checkCapabilities();

        // Check scan status (in case page was reloaded during scan)
        checkScanStatus();

        // Initialize proximity visualization
        initProximityRadar();

        // Initialize legacy heatmap (zone counts)
        initHeatmap();

        // Initialize device list filters
        initDeviceFilters();
        initListInteractions();

        // Set initial panel states
        updateVisualizationPanels();
    }

    /**
     * Initialize device list filter buttons
     */
    function initDeviceFilters() {
        if (filterListenersBound) return;
        const filterContainer = document.getElementById('btDeviceFilters');
        if (filterContainer) {
            filterContainer.addEventListener('click', (e) => {
                const btn = e.target.closest('.bt-filter-btn');
                if (!btn) return;

                const filter = btn.dataset.filter;
                if (!filter) return;

                // Update active state
                filterContainer.querySelectorAll('.bt-filter-btn').forEach(b => b.classList.remove('active'));
                btn.classList.add('active');

                // Apply filter
                currentDeviceFilter = filter;
                applyDeviceFilter();
            });
        }

        const searchInput = document.getElementById('btDeviceSearch');
        if (searchInput) {
            searchInput.addEventListener('input', () => {
                currentSearchTerm = searchInput.value.trim().toLowerCase();
                applyDeviceFilter();
            });
        }
        filterListenersBound = true;
    }

    function initListInteractions() {
        if (listListenersBound) return;
        if (deviceContainer) {
            deviceContainer.addEventListener('click', (event) => {
                const locateBtn = event.target.closest('.bt-locate-btn[data-locate-id]');
                if (locateBtn) {
                    event.preventDefault();
                    locateById(locateBtn.dataset.locateId);
                    return;
                }

                const row = event.target.closest('.bt-device-row[data-bt-device-id]');
                if (!row) return;
                selectDevice(row.dataset.btDeviceId);
            });
        }

        const trackerList = document.getElementById('btTrackerList');
        if (trackerList) {
            trackerList.addEventListener('click', (event) => {
                const row = event.target.closest('.bt-tracker-item[data-device-id]');
                if (!row) return;
                selectDevice(row.dataset.deviceId);
            });
        }
        listListenersBound = true;
    }

    /**
     * Apply current filter to device list
     */
    function applyDeviceFilter() {
        if (!deviceContainer) return;

        const cards = deviceContainer.querySelectorAll('[data-bt-device-id]');
        let visibleCount = 0;
        cards.forEach(card => {
            const isNew = card.dataset.isNew === 'true';
            const hasName = card.dataset.hasName === 'true';
            const rssi = parseInt(card.dataset.rssi) || -100;
            const isTracker = card.dataset.isTracker === 'true';
            const searchHaystack = (card.dataset.search || '').toLowerCase();

            let matchesFilter = true;
            switch (currentDeviceFilter) {
                case 'new':
                    matchesFilter = isNew;
                    break;
                case 'named':
                    matchesFilter = hasName;
                    break;
                case 'strong':
                    matchesFilter = rssi >= -70;
                    break;
                case 'trackers':
                    matchesFilter = isTracker;
                    break;
                case 'all':
                default:
                    matchesFilter = true;
            }

            const matchesSearch = !currentSearchTerm || searchHaystack.includes(currentSearchTerm);
            const visible = matchesFilter && matchesSearch;
            card.style.display = visible ? '' : 'none';
            if (visible) visibleCount++;
        });

        visibleDeviceCount = visibleCount;

        let stateEl = deviceContainer.querySelector('.bt-device-filter-state');
        if (visibleCount === 0 && devices.size > 0) {
            if (!stateEl) {
                stateEl = document.createElement('div');
                stateEl.className = 'bt-device-filter-state app-collection-state is-empty';
                deviceContainer.appendChild(stateEl);
            }
            stateEl.textContent = 'No devices match current filters';
        } else if (stateEl) {
            stateEl.remove();
        }

        // Update visible count
        updateFilteredCount();
    }

    /**
     * Update the device count display based on visible devices
     */
    function updateFilteredCount() {
        const countEl = document.getElementById('btDeviceListCount');
        if (!countEl || !deviceContainer) return;

        const hasFilter = currentDeviceFilter !== 'all' || currentSearchTerm.length > 0;
        countEl.textContent = hasFilter ? `${visibleDeviceCount}/${devices.size}` : devices.size;
    }

    /**
     * Initialize the new proximity radar component
     */
    function initProximityRadar() {
        const radarContainer = document.getElementById('btProximityRadar');
        if (!radarContainer) return;

        if (typeof ProximityRadar !== 'undefined') {
            ProximityRadar.init('btProximityRadar', {
                onDeviceClick: (deviceKey) => {
                    // Find device by key and show modal
                    const device = Array.from(devices.values()).find(d => d.device_key === deviceKey);
                    if (device) {
                        selectDevice(device.device_id);
                    }
                }
            });
            radarInitialized = true;

            // Setup radar controls
            setupRadarControls();
        }
    }

    /**
     * Setup radar control button handlers
     */
    function setupRadarControls() {
        // Filter buttons
        document.querySelectorAll('#btRadarControls button[data-filter]').forEach(btn => {
            btn.addEventListener('click', () => {
                const filter = btn.getAttribute('data-filter');
                if (typeof ProximityRadar !== 'undefined') {
                    ProximityRadar.setFilter(filter);

                    // Update button states
                    document.querySelectorAll('#btRadarControls button[data-filter]').forEach(b => {
                        b.classList.remove('active');
                    });
                    if (ProximityRadar.getFilter() === filter) {
                        btn.classList.add('active');
                    }
                }
            });
        });

        // Pause button
        const pauseBtn = document.getElementById('btRadarPauseBtn');
        if (pauseBtn) {
            pauseBtn.addEventListener('click', () => {
                radarPaused = !radarPaused;
                if (typeof ProximityRadar !== 'undefined') {
                    ProximityRadar.setPaused(radarPaused);
                }
                pauseBtn.textContent = radarPaused ? 'Resume' : 'Pause';
                pauseBtn.classList.toggle('active', radarPaused);
            });
        }
    }

    /**
     * Update the proximity radar with current devices
     */
    function updateRadar() {
        if (!radarInitialized || typeof ProximityRadar === 'undefined') return;

        // Convert devices map to array for radar
        const deviceList = Array.from(devices.values()).map(d => ({
            device_key: d.device_key || d.device_id,
            device_id: d.device_id,
            name: d.name,
            address: d.address,
            rssi_current: d.rssi_current,
            rssi_ema: d.rssi_ema,
            estimated_distance_m: d.estimated_distance_m,
            proximity_band: d.proximity_band || 'unknown',
            distance_confidence: d.distance_confidence || 0.5,
            is_new: d.is_new || !d.in_baseline,
            is_randomized_mac: d.is_randomized_mac,
            in_baseline: d.in_baseline,
            heuristic_flags: d.heuristic_flags || [],
            age_seconds: d.age_seconds || 0,
        }));

        ProximityRadar.updateDevices(deviceList);

        // Update zone counts from radar
        const counts = ProximityRadar.getZoneCounts();
        updateProximityZoneCounts(counts);
    }

    /**
     * Update proximity zone counts display (new system)
     */
    function updateProximityZoneCounts(counts) {
        const immediateEl = document.getElementById('btZoneImmediate');
        const nearEl = document.getElementById('btZoneNear');
        const farEl = document.getElementById('btZoneFar');

        if (immediateEl) immediateEl.textContent = counts.immediate || 0;
        if (nearEl) nearEl.textContent = counts.near || 0;
        if (farEl) farEl.textContent = counts.far || 0;
    }

    /**
     * Initialize proximity zones display
     */
    function initHeatmap() {
        updateProximityZones();
    }

    /**
     * Update proximity zone counts (simple HTML, no canvas)
     */
    function updateProximityZones() {
        zoneCounts = { immediate: 0, near: 0, far: 0 };

        devices.forEach(device => {
            const rssi = device.rssi_current;
            if (rssi == null) return;

            if (rssi >= -50) zoneCounts.immediate++;
            else if (rssi >= -70) zoneCounts.near++;
            else zoneCounts.far++;
        });

        updateProximityZoneCounts(zoneCounts);
    }

    // Currently selected device
    let selectedDeviceId = null;

    /**
     * Show device detail panel
     */
    function showDeviceDetail(deviceId) {
        const device = devices.get(deviceId);
        if (!device) return;

        selectedDeviceId = deviceId;

        const placeholder = document.getElementById('btDetailPlaceholder');
        const content = document.getElementById('btDetailContent');
        if (!placeholder || !content) return;

        const rssi = device.rssi_current;
        const rssiColor = getRssiColor(rssi);
        const flags = device.heuristic_flags || [];
        const protocol = device.protocol || 'ble';

        // Update panel elements
        document.getElementById('btDetailName').textContent = device.name || formatDeviceId(device.address);
        document.getElementById('btDetailAddress').textContent = isUuidAddress(device)
            ? 'CB: ' + device.address
            : device.address;

        // RSSI
        const rssiEl = document.getElementById('btDetailRssi');
        rssiEl.textContent = rssi != null ? rssi : '--';
        rssiEl.style.color = rssiColor;

        // Badges
        const badgesEl = document.getElementById('btDetailBadges');
        let badgesHtml = `<span class="bt-detail-badge ${protocol}">${protocol.toUpperCase()}</span>`;
        badgesHtml += `<span class="bt-detail-badge ${device.in_baseline ? 'baseline' : 'new'}">${device.in_baseline ? '✓ KNOWN' : '● NEW'}</span>`;
        if (device.seen_before) {
            badgesHtml += `<span class="bt-detail-badge flag">SEEN BEFORE</span>`;
        }

        // Tracker badge
        if (device.is_tracker) {
            const conf = device.tracker_confidence || 'low';
            const confClass = conf === 'high' ? 'tracker-high' : conf === 'medium' ? 'tracker-medium' : 'tracker-low';
            const typeLabel = device.tracker_name || device.tracker_type || 'TRACKER';
            badgesHtml += `<span class="bt-detail-badge ${confClass}">${escapeHtml(typeLabel)}</span>`;
        }

        flags.forEach(f => {
            badgesHtml += `<span class="bt-detail-badge flag">${f.replace(/_/g, ' ').toUpperCase()}</span>`;
        });
        badgesEl.innerHTML = badgesHtml;

        // Tracker analysis section
        const trackerSection = document.getElementById('btDetailTrackerAnalysis');
        if (trackerSection) {
            if (device.is_tracker) {
                const confidence = device.tracker_confidence || 'low';
                const confScore = device.tracker_confidence_score || 0;
                const riskScore = device.risk_score || 0;
                const evidence = device.tracker_evidence || [];
                const riskFactors = device.risk_factors || [];

                let trackerHtml = '<div class="bt-tracker-analysis">';
                trackerHtml += '<div class="bt-analysis-header">Tracker Detection Analysis</div>';

                // Confidence
                const confColor = confidence === 'high' ? '#ef4444' : confidence === 'medium' ? '#f97316' : '#eab308';
                trackerHtml += '<div class="bt-analysis-row"><span class="bt-analysis-label">Confidence:</span><span style="color:' + confColor + ';font-weight:600;">' + confidence.toUpperCase() + ' (' + Math.round(confScore * 100) + '%)</span></div>';

                // Evidence
                if (evidence.length > 0) {
                    trackerHtml += '<div class="bt-analysis-section"><div class="bt-analysis-label">Evidence:</div><ul class="bt-evidence-list">';
                    evidence.forEach(e => {
                        trackerHtml += '<li>' + escapeHtml(e) + '</li>';
                    });
                    trackerHtml += '</ul></div>';
                }

                // Risk analysis
                if (riskScore >= 0.1 || riskFactors.length > 0) {
                    const riskColor = riskScore >= 0.5 ? '#ef4444' : riskScore >= 0.3 ? '#f97316' : '#888';
                    trackerHtml += '<div class="bt-analysis-row"><span class="bt-analysis-label">Risk Score:</span><span style="color:' + riskColor + ';font-weight:600;">' + Math.round(riskScore * 100) + '%</span></div>';
                    if (riskFactors.length > 0) {
                        trackerHtml += '<div class="bt-analysis-section"><div class="bt-analysis-label">Risk Factors:</div><ul class="bt-evidence-list">';
                        riskFactors.forEach(f => {
                            trackerHtml += '<li>' + escapeHtml(f) + '</li>';
                        });
                        trackerHtml += '</ul></div>';
                    }
                }

                trackerHtml += '<div class="bt-analysis-warning">Note: Detection is heuristic-based. Results indicate patterns consistent with tracking devices but cannot prove intent.</div>';
                trackerHtml += '</div>';

                trackerSection.style.display = 'block';
                trackerSection.innerHTML = trackerHtml;
            } else {
                trackerSection.style.display = 'none';
                trackerSection.innerHTML = '';
            }
        }

        // Stats grid
        document.getElementById('btDetailMfr').textContent = device.manufacturer_name || '--';
        document.getElementById('btDetailMfrId').textContent = device.manufacturer_id != null
            ? '0x' + device.manufacturer_id.toString(16).toUpperCase().padStart(4, '0')
            : '--';
        document.getElementById('btDetailAddrType').textContent = device.address_type || '--';
        document.getElementById('btDetailSeen').textContent = (device.seen_count || 0) + '×';
        document.getElementById('btDetailRange').textContent = device.range_band || '--';

        // Min/Max combined
        const minMax = [];
        if (device.rssi_min != null) minMax.push(device.rssi_min);
        if (device.rssi_max != null) minMax.push(device.rssi_max);
        document.getElementById('btDetailRssiRange').textContent = minMax.length === 2
            ? minMax[0] + '/' + minMax[1]
            : '--';

        document.getElementById('btDetailFirstSeen').textContent = device.first_seen
            ? new Date(device.first_seen).toLocaleTimeString()
            : '--';
        document.getElementById('btDetailLastSeen').textContent = device.last_seen
            ? new Date(device.last_seen).toLocaleTimeString()
            : '--';

        // New stat cells
        document.getElementById('btDetailTxPower').textContent = device.tx_power != null
            ? device.tx_power + ' dBm' : '--';
        document.getElementById('btDetailSeenRate').textContent = device.seen_rate != null
            ? device.seen_rate.toFixed(1) + '/min' : '--';

        // Stability from variance
        const stabilityEl = document.getElementById('btDetailStability');
        if (device.rssi_variance != null) {
            let stabLabel, stabColor;
            if (device.rssi_variance <= 5) { stabLabel = 'Stable'; stabColor = '#22c55e'; }
            else if (device.rssi_variance <= 25) { stabLabel = 'Moderate'; stabColor = '#eab308'; }
            else { stabLabel = 'Unstable'; stabColor = '#ef4444'; }
            stabilityEl.textContent = stabLabel;
            stabilityEl.style.color = stabColor;
        } else {
            stabilityEl.textContent = '--';
            stabilityEl.style.color = '';
        }

        // Distance with confidence
        const distEl = document.getElementById('btDetailDistance');
        if (device.estimated_distance_m != null) {
            const confPct = Math.round((device.distance_confidence || 0) * 100);
            distEl.textContent = device.estimated_distance_m.toFixed(1) + 'm ±' + confPct + '%';
        } else {
            distEl.textContent = '--';
        }

        // Appearance badge
        if (device.appearance_name) {
            badgesHtml += '<span class="bt-detail-badge flag">' + escapeHtml(device.appearance_name) + '</span>';
            badgesEl.innerHTML = badgesHtml;
        }

        // MAC cluster indicator
        const macClusterEl = document.getElementById('btDetailMacCluster');
        if (macClusterEl) {
            if (device.mac_cluster_count > 1) {
                macClusterEl.textContent = device.mac_cluster_count + ' MACs';
                macClusterEl.style.display = '';
            } else {
                macClusterEl.style.display = 'none';
            }
        }

        // Service data inspector
        const inspectorEl = document.getElementById('btDetailServiceInspector');
        const inspectorContent = document.getElementById('btInspectorContent');
        if (inspectorEl && inspectorContent) {
            const hasData = device.manufacturer_bytes || device.appearance != null ||
                (device.service_data && Object.keys(device.service_data).length > 0);
            if (hasData) {
                inspectorEl.style.display = '';
                let inspHtml = '';
                if (device.appearance != null) {
                    const name = device.appearance_name || '';
                    inspHtml += '<div class="bt-inspector-row"><span class="bt-inspector-label">Appearance</span><span class="bt-inspector-value">0x' + device.appearance.toString(16).toUpperCase().padStart(4, '0') + (name ? ' (' + escapeHtml(name) + ')' : '') + '</span></div>';
                }
                if (device.manufacturer_bytes) {
                    inspHtml += '<div class="bt-inspector-row"><span class="bt-inspector-label">Mfr Data</span><span class="bt-inspector-value">' + escapeHtml(device.manufacturer_bytes) + '</span></div>';
                }
                if (device.service_data) {
                    Object.entries(device.service_data).forEach(([uuid, hex]) => {
                        inspHtml += '<div class="bt-inspector-row"><span class="bt-inspector-label">' + escapeHtml(uuid) + '</span><span class="bt-inspector-value">' + escapeHtml(hex) + '</span></div>';
                    });
                }
                inspectorContent.innerHTML = inspHtml;
            } else {
                inspectorEl.style.display = 'none';
            }
        }

        updateWatchlistButton(device);

        // IRK
        const irkContainer = document.getElementById('btDetailIrk');
        if (irkContainer) {
            if (device.has_irk) {
                irkContainer.style.display = 'block';
                const irkVal = document.getElementById('btDetailIrkValue');
                if (irkVal) {
                    const label = device.irk_source_name
                        ? device.irk_source_name + ' — ' + device.irk_hex
                        : device.irk_hex;
                    irkVal.textContent = label;
                }
            } else {
                irkContainer.style.display = 'none';
            }
        }

        // Services
        const servicesContainer = document.getElementById('btDetailServices');
        const servicesList = document.getElementById('btDetailServicesList');
        if (device.service_uuids && device.service_uuids.length > 0) {
            servicesContainer.style.display = 'block';
            servicesList.textContent = device.service_uuids.join(', ');
        } else {
            servicesContainer.style.display = 'none';
        }

        // Show content, hide placeholder
        placeholder.style.display = 'none';
        content.style.display = 'block';

        // Highlight selected device in list
        highlightSelectedDevice(deviceId);
    }

    /**
     * Update watchlist button state
     */
    function updateWatchlistButton(device) {
        const btn = document.getElementById('btDetailWatchBtn');
        if (!btn) return;
        if (typeof AlertCenter === 'undefined') {
            btn.style.display = 'none';
            return;
        }
        btn.style.display = '';
        const watchlisted = AlertCenter.isWatchlisted(device.address);
        btn.textContent = watchlisted ? 'Watching' : 'Watchlist';
        btn.classList.toggle('active', watchlisted);
    }

    /**
     * Clear device selection
     */
    function clearSelection() {
        selectedDeviceId = null;

        const placeholder = document.getElementById('btDetailPlaceholder');
        const content = document.getElementById('btDetailContent');
        if (placeholder) placeholder.style.display = 'flex';
        if (content) content.style.display = 'none';

        // Remove highlight from device list
        if (deviceContainer) {
            deviceContainer.querySelectorAll('.bt-device-row.selected').forEach(el => {
                el.classList.remove('selected');
            });
        }

        // Clear radar highlight
        if (typeof ProximityRadar !== 'undefined') {
            ProximityRadar.clearHighlight();
        }
    }

    /**
     * Highlight selected device in the list
     */
    function highlightSelectedDevice(deviceId) {
        if (!deviceContainer) return;

        // Remove existing highlights
        deviceContainer.querySelectorAll('.bt-device-row.selected').forEach(el => {
            el.classList.remove('selected');
        });

        // Add highlight to selected device
        const escapedId = CSS.escape(deviceId);
        const card = deviceContainer.querySelector(`[data-bt-device-id="${escapedId}"]`);
        if (card) {
            card.classList.add('selected');
        }

        // Also highlight on the radar
        const device = devices.get(deviceId);
        if (device && typeof ProximityRadar !== 'undefined') {
            ProximityRadar.highlightDevice(device.device_key || device.device_id);
        }
    }

    /**
     * Copy selected device address to clipboard
     */
    function copyAddress() {
        if (!selectedDeviceId) return;
        const device = devices.get(selectedDeviceId);
        if (!device) return;

        navigator.clipboard.writeText(device.address).then(() => {
            const btn = document.getElementById('btDetailCopyBtn');
            if (btn) {
                const originalText = btn.textContent;
                btn.textContent = 'Copied!';
                btn.style.background = '#22c55e';
                setTimeout(() => {
                    btn.textContent = originalText;
                    btn.style.background = '';
                }, 1500);
            }
        });
    }

    /**
     * Toggle Bluetooth watchlist for selected device
     */
    function toggleWatchlist() {
        if (!selectedDeviceId) return;
        const device = devices.get(selectedDeviceId);
        if (!device || typeof AlertCenter === 'undefined') return;

        if (AlertCenter.isWatchlisted(device.address)) {
            AlertCenter.removeBluetoothWatchlist(device.address);
            showInfo('Removed from watchlist');
        } else {
            AlertCenter.addBluetoothWatchlist(device.address, device.name || device.address);
            showInfo('Added to watchlist');
        }

        setTimeout(() => updateWatchlistButton(device), 200);
    }

    /**
     * Select a device - opens modal with details
     */
    function selectDevice(deviceId) {
        showDeviceDetail(deviceId);
    }

    /**
     * Format device ID for display (when no name available)
     */
    function formatDeviceId(address) {
        if (!address) return 'Unknown Device';
        const parts = address.split(':');
        if (parts.length === 6) {
            return parts[0] + ':' + parts[1] + ':...:' + parts[4] + ':' + parts[5];
        }
        // CoreBluetooth UUID format (8-4-4-4-12)
        if (/^[0-9A-F]{8}-[0-9A-F]{4}-/i.test(address)) {
            return address.substring(0, 8) + '...';
        }
        return address;
    }

    function isUuidAddress(device) {
        return device.address_type === 'uuid';
    }

    function formatAddress(device) {
        if (!device || !device.address) return '--';
        if (isUuidAddress(device)) {
            return device.address.substring(0, 8) + '-...' + device.address.slice(-4);
        }
        return device.address;
    }

    /**
     * Check system capabilities
     */
    async function checkCapabilities() {
        try {
            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
            let data;

            if (isAgentMode) {
                // Fetch capabilities from agent via controller proxy
                const response = await fetch(`/controller/agents/${currentAgent}?refresh=true`);
                const agentData = await response.json();

                if (agentData.agent && agentData.agent.capabilities) {
                    const agentCaps = agentData.agent.capabilities;
                    const agentInterfaces = agentData.agent.interfaces || {};

                    // Build BT-compatible capabilities object
                    data = {
                        available: agentCaps.bluetooth || false,
                        adapters: (agentInterfaces.bt_adapters || []).map(adapter => ({
                            id: adapter.id || adapter.name || adapter,
                            name: adapter.name || adapter,
                            powered: adapter.powered !== false
                        })),
                        issues: [],
                        preferred_backend: 'auto'
                    };
                    console.log('[BT] Agent capabilities:', data);
                } else {
                    data = { available: false, adapters: [], issues: ['Agent does not support Bluetooth'] };
                }
            } else {
                const response = await fetch('/api/bluetooth/capabilities');
                data = await response.json();
            }

            if (!data.available) {
                showCapabilityWarning(['Bluetooth not available on this system']);
                return;
            }

            if (adapterSelect && data.adapters && data.adapters.length > 0) {
                adapterSelect.innerHTML = data.adapters.map(a => {
                    const status = a.powered ? 'UP' : 'DOWN';
                    return `<option value="${a.id}">${a.id} - ${a.name || 'Bluetooth Adapter'} [${status}]</option>`;
                }).join('');
            } else if (adapterSelect) {
                adapterSelect.innerHTML = '<option value="">No adapters found</option>';
            }

            if (data.issues && data.issues.length > 0) {
                showCapabilityWarning(data.issues);
            } else {
                hideCapabilityWarning();
            }

            // Show/hide Ubertooth option based on capabilities
            const ubertoothOption = document.getElementById('btScanModeUbertooth');
            if (ubertoothOption) {
                ubertoothOption.style.display = data.has_ubertooth ? '' : 'none';
            }

            if (scanModeSelect && data.preferred_backend) {
                const option = scanModeSelect.querySelector(`option[value="${data.preferred_backend}"]`);
                if (option) option.selected = true;
            }

        } catch (err) {
            console.error('Failed to check capabilities:', err);
            showCapabilityWarning(['Failed to check Bluetooth capabilities']);
        }
    }

    function showCapabilityWarning(issues) {
        if (!capabilityStatusEl) return;
        capabilityStatusEl.style.display = 'block';
        capabilityStatusEl.innerHTML = `
            <div style="color: #f59e0b; padding: 10px; background: rgba(245,158,11,0.1); border-radius: 6px; font-size: 12px;">
                ${issues.map(i => `<div>⚠ ${i}</div>`).join('')}
            </div>
        `;
    }

    function hideCapabilityWarning() {
        if (capabilityStatusEl) {
            capabilityStatusEl.style.display = 'none';
            capabilityStatusEl.innerHTML = '';
        }
    }

    async function checkScanStatus() {
        try {
            const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
            const endpoint = isAgentMode
                ? `/controller/agents/${currentAgent}/bluetooth/status`
                : '/api/bluetooth/scan/status';

            const response = await fetch(endpoint);
            const responseData = await response.json();
            // Handle agent response format (may be nested in 'result')
            const data = isAgentMode && responseData.result ? responseData.result : responseData;

            if (data.is_scanning || data.running) {
                setScanning(true);
                startEventStream();
            }

            if (data.baseline_count > 0) {
                baselineSet = true;
                baselineCount = data.baseline_count;
                updateBaselineStatus();
            }

        } catch (err) {
            console.error('Failed to check scan status:', err);
        }
    }

    async function startScan() {
        // Check for agent mode conflicts
        if (!await checkAgentConflicts()) {
            return;
        }

        const adapter = adapterSelect?.value || '';
        const mode = scanModeSelect?.value || 'auto';
        const transport = transportSelect?.value || 'auto';
        const duration = parseInt(durationInput?.value || '0', 10);
        const minRssi = parseInt(minRssiInput?.value || '-100', 10);

        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';

        if (startBtn) startBtn.classList.add('btn-loading');
        try {
            let response;
            if (isAgentMode) {
                // Route through agent proxy
                response = await fetch(`/controller/agents/${currentAgent}/bluetooth/start`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        mode: mode,
                        adapter_id: adapter || undefined,
                        duration_s: duration > 0 ? duration : undefined,
                        transport: transport,
                        rssi_threshold: minRssi
                    })
                });
            } else {
                response = await fetch('/api/bluetooth/scan/start', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        mode: mode,
                        adapter_id: adapter || undefined,
                        duration_s: duration > 0 ? duration : undefined,
                        transport: transport,
                        rssi_threshold: minRssi
                    })
                });
            }

            const data = await response.json();

            // Handle controller proxy response format (agent response is nested in 'result')
            const scanResult = isAgentMode && data.result ? data.result : data;

            if (scanResult.status === 'started' || scanResult.status === 'already_scanning') {
                setScanning(true);
                startEventStream();
            } else if (scanResult.status === 'error') {
                showErrorMessage(scanResult.message || 'Failed to start scan');
            } else {
                showErrorMessage(scanResult.message || 'Failed to start scan');
            }

        } catch (err) {
            console.error('Failed to start scan:', err);
            reportActionableError('Start Bluetooth Scan', err, {
                onRetry: () => startScan()
            });
        } finally {
            if (startBtn) startBtn.classList.remove('btn-loading');
        }
    }

    async function stopScan() {
        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
        const timeoutMs = isAgentMode ? 8000 : 2200;
        const controller = (typeof AbortController !== 'undefined') ? new AbortController() : null;
        const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;

        // Optimistic UI teardown keeps mode changes responsive.
        setScanning(false);
        stopEventStream();

        try {
            if (isAgentMode) {
                await fetch(`/controller/agents/${currentAgent}/bluetooth/stop`, {
                    method: 'POST',
                    ...(controller ? { signal: controller.signal } : {}),
                });
            } else {
                await fetch('/api/bluetooth/scan/stop', {
                    method: 'POST',
                    ...(controller ? { signal: controller.signal } : {}),
                });
            }
        } catch (err) {
            console.error('Failed to stop scan:', err);
            reportActionableError('Stop Bluetooth Scan', err);
        } finally {
            if (timeoutId) {
                clearTimeout(timeoutId);
            }
        }
    }

    function setScanning(scanning) {
        isScanning = scanning;

        if (startBtn) startBtn.style.display = scanning ? 'none' : 'block';
        if (stopBtn) stopBtn.style.display = scanning ? 'block' : 'none';

        if (scanning && deviceContainer) {
            pendingDeviceIds.clear();
            selectedDeviceNeedsRefresh = false;
            pendingDeviceFlush = false;
            if (typeof renderCollectionState === 'function') {
                renderCollectionState(deviceContainer, { type: 'loading', message: 'Scanning for Bluetooth devices...' });
            } else {
                deviceContainer.innerHTML = '';
            }
            devices.clear();
            resetStats();
        } else if (!scanning && deviceContainer && devices.size === 0) {
            if (typeof renderCollectionState === 'function') {
                renderCollectionState(deviceContainer, { type: 'empty', message: 'Start scanning to discover Bluetooth devices' });
            }
        }

        const statusDot = document.getElementById('statusDot');
        const statusText = document.getElementById('statusText');
        if (statusDot) statusDot.classList.toggle('running', scanning);
        if (statusText) statusText.textContent = scanning ? 'Scanning...' : 'Idle';
    }

    function resetStats() {
        deviceStats = {
            strong: 0,
            medium: 0,
            weak: 0,
            trackers: []
        };
        visibleDeviceCount = 0;
        updateVisualizationPanels();
        updateProximityZones();
        updateFilteredCount();

        // Clear radar
        if (radarInitialized && typeof ProximityRadar !== 'undefined') {
            ProximityRadar.clear();
        }
    }

    function startEventStream() {
        if (eventSource) eventSource.close();

        const isAgentMode = typeof currentAgent !== 'undefined' && currentAgent !== 'local';
        const agentName = getCurrentAgentName();
        let streamUrl;

        if (isAgentMode) {
            // Use multi-agent stream for remote agents
            streamUrl = '/controller/stream/all';
            console.log('[BT] Starting multi-agent event stream...');
        } else {
            streamUrl = '/api/bluetooth/stream';
            console.log('[BT] Starting local event stream...');
        }

        eventSource = new EventSource(streamUrl);

        if (isAgentMode) {
            // Handle multi-agent stream
            eventSource.onmessage = (e) => {
                try {
                    const data = JSON.parse(e.data);

                    // Skip keepalive and non-bluetooth data
                    if (data.type === 'keepalive') return;
                    if (data.scan_type !== 'bluetooth') return;

                    // Filter by current agent if not in "show all" mode
                    if (!showAllAgentsMode && typeof agents !== 'undefined') {
                        const currentAgentObj = agents.find(a => a.id == currentAgent);
                        if (currentAgentObj && data.agent_name && data.agent_name !== currentAgentObj.name) {
                            return;
                        }
                    }

                    // Transform multi-agent payload to device updates
                    if (data.payload && data.payload.devices) {
                        Object.values(data.payload.devices).forEach(device => {
                            device._agent = data.agent_name || 'Unknown';
                            handleDeviceUpdate(device);
                        });
                    }
                } catch (err) {
                    console.error('Failed to parse multi-agent event:', err);
                }
            };

            // Also start polling as fallback (in case push isn't enabled on agent)
            startAgentPolling();
        } else {
            // Handle local stream
            eventSource.addEventListener('device_update', (e) => {
                try {
                    const device = JSON.parse(e.data);
                    device._agent = 'Local';
                    handleDeviceUpdate(device);
                } catch (err) {
                    console.error('Failed to parse device update:', err);
                }
            });

            eventSource.addEventListener('scan_started', (e) => {
                setScanning(true);
            });

            eventSource.addEventListener('scan_stopped', (e) => {
                setScanning(false);
            });
        }

        eventSource.onerror = () => {
            console.warn('Bluetooth SSE connection error');
            if (isScanning) {
                // Attempt to reconnect
                setTimeout(() => {
                    if (isScanning) {
                        startEventStream();
                    }
                }, 3000);
            }
        };
    }

    function stopEventStream() {
        if (eventSource) {
            eventSource.close();
            eventSource = null;
        }
        if (agentPollTimer) {
            clearInterval(agentPollTimer);
            agentPollTimer = null;
        }
    }

    /**
     * Start polling agent data as fallback when push isn't enabled.
     * This polls the controller proxy endpoint for agent data.
     */
    function startAgentPolling() {
        if (agentPollTimer) return;

        const pollInterval = 3000;  // 3 seconds
        console.log('[BT] Starting agent polling fallback...');

        agentPollTimer = setInterval(async () => {
            if (!isScanning) {
                clearInterval(agentPollTimer);
                agentPollTimer = null;
                return;
            }

            try {
                const response = await fetch(`/controller/agents/${currentAgent}/bluetooth/data`);
                if (!response.ok) return;

                const result = await response.json();
                const data = result.data || result;

                // Process devices from polling response
                if (data && data.devices) {
                    const agentName = getCurrentAgentName();
                    Object.values(data.devices).forEach(device => {
                        device._agent = agentName;
                        handleDeviceUpdate(device);
                    });
                } else if (data && Array.isArray(data)) {
                    const agentName = getCurrentAgentName();
                    data.forEach(device => {
                        device._agent = agentName;
                        handleDeviceUpdate(device);
                    });
                }
            } catch (err) {
                console.debug('[BT] Agent poll error:', err);
            }
        }, pollInterval);
    }

    function handleDeviceUpdate(device) {
        devices.set(device.device_id, device);
        pendingDeviceIds.add(device.device_id);
        if (selectedDeviceId === device.device_id) {
            selectedDeviceNeedsRefresh = true;
        }
        scheduleDeviceFlush();
    }

    function scheduleDeviceFlush() {
        if (pendingDeviceFlush) return;
        pendingDeviceFlush = true;

        requestAnimationFrame(() => {
            pendingDeviceFlush = false;

            pendingDeviceIds.forEach((deviceId) => {
                const device = devices.get(deviceId);
                if (device) {
                    renderDevice(device, false);
                }
            });
            pendingDeviceIds.clear();

            applyDeviceFilter();
            updateDeviceCount();
            updateStatsFromDevices();
            updateVisualizationPanels();
            updateProximityZones();
            updateRadar();

            if (selectedDeviceNeedsRefresh && selectedDeviceId && devices.has(selectedDeviceId)) {
                showDeviceDetail(selectedDeviceId);
            }
            selectedDeviceNeedsRefresh = false;
        });
    }

    /**
     * Update stats from all devices
     */
    function updateStatsFromDevices() {
        // Reset counts
        deviceStats.strong = 0;
        deviceStats.medium = 0;
        deviceStats.weak = 0;
        deviceStats.trackers = [];

        devices.forEach(d => {
            const rssi = d.rssi_current;

            // Signal strength classification
            if (rssi != null) {
                if (rssi >= -50) deviceStats.strong++;
                else if (rssi >= -70) deviceStats.medium++;
                else deviceStats.weak++;
            }

            // Use actual tracker detection from backend (v2)
            // The is_tracker field comes from the TrackerSignatureEngine
            if (d.is_tracker === true) {
                if (!deviceStats.trackers.find(t => t.address === d.address)) {
                    deviceStats.trackers.push(d);
                }
            }
        });
    }

    /**
     * Update visualization panels
     */
    function updateVisualizationPanels() {
        // Signal Distribution
        const total = devices.size || 1;
        const strongBar = document.getElementById('btSignalStrong');
        const mediumBar = document.getElementById('btSignalMedium');
        const weakBar = document.getElementById('btSignalWeak');
        const strongCount = document.getElementById('btSignalStrongCount');
        const mediumCount = document.getElementById('btSignalMediumCount');
        const weakCount = document.getElementById('btSignalWeakCount');

        if (strongBar) strongBar.style.width = (deviceStats.strong / total * 100) + '%';
        if (mediumBar) mediumBar.style.width = (deviceStats.medium / total * 100) + '%';
        if (weakBar) weakBar.style.width = (deviceStats.weak / total * 100) + '%';
        if (strongCount) strongCount.textContent = deviceStats.strong;
        if (mediumCount) mediumCount.textContent = deviceStats.medium;
        if (weakCount) weakCount.textContent = deviceStats.weak;

        // Device summary strip
        const totalEl = document.getElementById('btSummaryTotal');
        const newEl = document.getElementById('btSummaryNew');
        const trackersEl = document.getElementById('btSummaryTrackers');
        const strongestEl = document.getElementById('btSummaryStrongest');
        if (totalEl || newEl || trackersEl || strongestEl) {
            let newCount = 0;
            let strongest = null;
            devices.forEach(d => {
                if (!d.in_baseline) newCount++;
                if (d.rssi_current != null) {
                    strongest = strongest == null ? d.rssi_current : Math.max(strongest, d.rssi_current);
                }
            });
            if (totalEl) totalEl.textContent = devices.size;
            if (newEl) newEl.textContent = newCount;
            if (trackersEl) trackersEl.textContent = deviceStats.trackers.length;
            if (strongestEl) strongestEl.textContent = strongest == null ? '--' : `${strongest} dBm`;
        }

        // Tracker Detection - Enhanced display with confidence and evidence
        const trackerList = document.getElementById('btTrackerList');
        if (trackerList) {
            if (devices.size === 0) {
                if (typeof renderCollectionState === 'function') {
                    renderCollectionState(trackerList, { type: 'empty', message: 'Start scanning to detect trackers' });
                } else {
                    trackerList.innerHTML = '<div class="app-collection-state is-empty">Start scanning to detect trackers</div>';
                }
            } else if (deviceStats.trackers.length === 0) {
                if (typeof renderCollectionState === 'function') {
                    renderCollectionState(trackerList, { type: 'empty', message: 'No trackers detected' });
                } else {
                    trackerList.innerHTML = '<div class="app-collection-state is-empty">No trackers detected</div>';
                }
            } else {
                // Sort by risk score (highest first), then confidence
                const sortedTrackers = [...deviceStats.trackers].sort((a, b) => {
                    const riskA = a.risk_score || 0;
                    const riskB = b.risk_score || 0;
                    if (riskB !== riskA) return riskB - riskA;
                    const confA = a.tracker_confidence_score || 0;
                    const confB = b.tracker_confidence_score || 0;
                    return confB - confA;
                });

                trackerList.innerHTML = sortedTrackers.map((t) => {
                    const confidence = t.tracker_confidence || 'low';
                    const riskScore = t.risk_score || 0;
                    const trackerType = t.tracker_name || t.tracker_type || 'Unknown Tracker';
                    const evidence = (t.tracker_evidence || []).slice(0, 2);
                    const evidenceHtml = evidence.length > 0
                        ? `<div class="bt-tracker-evidence">${evidence.map((e) => `• ${escapeHtml(e)}`).join('<br>')}</div>`
                        : '';
                    const riskClass = riskScore >= 0.5 ? 'high' : riskScore >= 0.3 ? 'medium' : 'low';
                    const riskHtml = riskScore >= 0.3
                        ? `<span class="bt-tracker-risk bt-risk-${riskClass}">RISK ${Math.round(riskScore * 100)}%</span>`
                        : '';

                    return `
                        <div class="bt-tracker-item bt-tracker-confidence-${escapeHtml(confidence)}" data-device-id="${escapeAttr(t.device_id)}" role="button" tabindex="0" data-keyboard-activate="true">
                            <div class="bt-tracker-row-top">
                                <div class="bt-tracker-left">
                                    <span class="bt-tracker-confidence">${escapeHtml(confidence.toUpperCase())}</span>
                                    <span class="bt-tracker-type">${escapeHtml(trackerType)}</span>
                                </div>
                                <div class="bt-tracker-right">
                                    ${riskHtml}
                                    <span class="bt-tracker-rssi">${t.rssi_current != null ? t.rssi_current : '--'} dBm</span>
                                </div>
                            </div>
                            <div class="bt-tracker-row-bottom">
                                <span class="bt-tracker-address">${escapeHtml(t.address_type === 'uuid' ? formatAddress(t) : (t.address || '--'))}</span>
                                <span class="bt-tracker-seen">Seen ${t.seen_count || 0}x</span>
                            </div>
                            ${evidenceHtml}
                        </div>
                    `;
                }).join('');
            }
        }

    }

    function updateDeviceCount() {
        updateFilteredCount();
    }

    function renderDevice(device, reapplyFilter = true) {
        if (!deviceContainer) {
            deviceContainer = document.getElementById('btDeviceListContent');
            if (!deviceContainer) return;
        }

        deviceContainer.querySelectorAll('.app-collection-state, .bt-device-filter-state').forEach((el) => el.remove());

        const escapedId = CSS.escape(device.device_id);
        const existingCard = deviceContainer.querySelector('[data-bt-device-id="' + escapedId + '"]');
        const cardHtml = createSimpleDeviceCard(device);

        if (existingCard) {
            existingCard.outerHTML = cardHtml;
        } else {
            deviceContainer.insertAdjacentHTML('afterbegin', cardHtml);
        }

        if (reapplyFilter) {
            applyDeviceFilter();
        }
    }

    function createSimpleDeviceCard(device) {
        const protocol = device.protocol || 'ble';
        const rssi = device.rssi_current;
        const rssiColor = getRssiColor(rssi);
        const inBaseline = device.in_baseline || false;
        const isNew = !inBaseline;
        const hasName = !!device.name;
        const isTracker = device.is_tracker === true;
        const trackerType = device.tracker_type;
        const trackerConfidence = device.tracker_confidence;
        const riskScore = device.risk_score || 0;
        const agentName = device._agent || 'Local';
        const seenBefore = device.seen_before === true;

        // Calculate RSSI bar width (0-100%)
        // RSSI typically ranges from -100 (weak) to -30 (very strong)
        const rssiPercent = rssi != null ? Math.max(0, Math.min(100, ((rssi + 100) / 70) * 100)) : 0;

        const displayName = device.name || formatDeviceId(device.address);
        const name = escapeHtml(displayName);
        const addr = escapeHtml(isUuidAddress(device) ? formatAddress(device) : (device.address || 'Unknown'));
        const mfr = device.manufacturer_name ? escapeHtml(device.manufacturer_name) : '';
        const seenCount = device.seen_count || 0;
        const searchIndex = [
            displayName,
            device.address,
            device.manufacturer_name,
            device.tracker_name,
            device.tracker_type,
            agentName
        ].filter(Boolean).join(' ').toLowerCase();

        // Protocol badge - compact
        const protoBadge = protocol === 'ble'
            ? '<span class="bt-proto-badge ble">BLE</span>'
            : '<span class="bt-proto-badge classic">CLASSIC</span>';

        // Tracker badge - show if device is detected as tracker
        let trackerBadge = '';
        if (isTracker) {
            const confColor = trackerConfidence === 'high' ? '#ef4444' :
                             trackerConfidence === 'medium' ? '#f97316' : '#eab308';
            const confBg = trackerConfidence === 'high' ? 'rgba(239,68,68,0.15)' :
                          trackerConfidence === 'medium' ? 'rgba(249,115,22,0.15)' : 'rgba(234,179,8,0.15)';
            const typeLabel = trackerType === 'airtag' ? 'AirTag' :
                             trackerType === 'tile' ? 'Tile' :
                             trackerType === 'samsung_smarttag' ? 'SmartTag' :
                             trackerType === 'findmy_accessory' ? 'FindMy' :
                             trackerType === 'chipolo' ? 'Chipolo' : 'TRACKER';
            trackerBadge = '<span class="bt-tracker-badge" style="background:' + confBg + ';color:' + confColor + ';font-size:9px;padding:1px 4px;border-radius:3px;margin-left:4px;font-weight:600;">' + typeLabel + '</span>';
        }

        // IRK badge - show if paired IRK is available
        let irkBadge = '';
        if (device.has_irk) {
            irkBadge = '<span class="bt-irk-badge">IRK</span>';
        }

        // Risk badge - show if risk score is significant
        let riskBadge = '';
        if (riskScore >= 0.3) {
            const riskColor = riskScore >= 0.5 ? '#ef4444' : '#f97316';
            riskBadge = '<span class="bt-risk-badge" style="color:' + riskColor + ';font-size:8px;margin-left:4px;font-weight:600;">' + Math.round(riskScore * 100) + '% RISK</span>';
        }

        // Status indicator
        let statusDot;
        if (isTracker && trackerConfidence === 'high') {
            statusDot = '<span class="bt-status-dot tracker" style="background:#ef4444;"></span>';
        } else if (isNew) {
            statusDot = '<span class="bt-status-dot new"></span>';
        } else {
            statusDot = '<span class="bt-status-dot known"></span>';
        }

        // Distance display
        const distM = device.estimated_distance_m;
        let distStr = '';
        if (distM != null) {
            distStr = '~' + distM.toFixed(1) + 'm';
        }

        // Behavioral flag badges
        const hFlags = device.heuristic_flags || [];
        let flagBadges = '';
        if (device.is_persistent || hFlags.includes('persistent')) {
            flagBadges += '<span class="bt-flag-badge persistent">PERSIST</span>';
        }
        if (device.is_beacon_like || hFlags.includes('beacon_like')) {
            flagBadges += '<span class="bt-flag-badge beacon-like">BEACON</span>';
        }
        if (device.is_strong_stable || hFlags.includes('strong_stable')) {
            flagBadges += '<span class="bt-flag-badge strong-stable">STABLE</span>';
        }

        // MAC cluster badge
        let clusterBadge = '';
        if (device.mac_cluster_count > 1) {
            clusterBadge = '<span class="bt-mac-cluster-badge">' + device.mac_cluster_count + ' MACs</span>';
        }

        // Build secondary info line
        let secondaryParts = [addr];
        if (mfr) secondaryParts.push(mfr);
        if (distStr) secondaryParts.push(distStr);
        secondaryParts.push('Seen ' + seenCount + '×');
        if (seenBefore) secondaryParts.push('<span class="bt-history-badge">SEEN BEFORE</span>');
        // Add agent name if not Local
        if (agentName !== 'Local') {
            secondaryParts.push('<span class="agent-badge agent-remote" style="font-size:8px;padding:1px 4px;">' + escapeHtml(agentName) + '</span>');
        }
        const secondaryInfo = secondaryParts.join(' · ');

        // Row border color - highlight trackers in red/orange
        const borderColor = isTracker && trackerConfidence === 'high' ? '#ef4444' :
                           isTracker ? '#f97316' : rssiColor;

        return '<div class="bt-device-row' + (isTracker ? ' is-tracker' : '') + '" data-bt-device-id="' + escapeAttr(device.device_id) + '" data-is-new="' + isNew + '" data-has-name="' + hasName + '" data-rssi="' + (rssi || -100) + '" data-is-tracker="' + isTracker + '" data-search="' + escapeAttr(searchIndex) + '" role="button" tabindex="0" data-keyboard-activate="true" style="border-left-color:' + borderColor + ';">' +
            '<div class="bt-row-main">' +
                '<div class="bt-row-left">' +
                    protoBadge +
                    '<span class="bt-device-name">' + name + '</span>' +
                    trackerBadge +
                    irkBadge +
                    riskBadge +
                    flagBadges +
                    clusterBadge +
                '</div>' +
                '<div class="bt-row-right">' +
                    '<div class="bt-rssi-container">' +
                        '<div class="bt-rssi-bar-bg"><div class="bt-rssi-bar" style="width:' + rssiPercent + '%;background:' + rssiColor + ';"></div></div>' +
                        '<span class="bt-rssi-value" style="color:' + rssiColor + ';">' + (rssi != null ? rssi : '--') + '</span>' +
                    '</div>' +
                    statusDot +
                '</div>' +
            '</div>' +
            '<div class="bt-row-secondary">' + secondaryInfo + '</div>' +
            '<div class="bt-row-actions">' +
                '<button type="button" class="bt-locate-btn" data-locate-id="' + escapeAttr(device.device_id) + '">' +
                    '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="10" r="3"/><path d="M12 21.7C17.3 17 20 13 20 10a8 8 0 1 0-16 0c0 3 2.7 7 8 11.7z"/></svg>' +
                    'Locate</button>' +
            '</div>' +
        '</div>';
    }

    function getRssiColor(rssi) {
        if (rssi == null) return '#666';
        if (rssi >= -50) return '#22c55e';
        if (rssi >= -60) return '#84cc16';
        if (rssi >= -70) return '#eab308';
        if (rssi >= -80) return '#f97316';
        return '#ef4444';
    }

    function escapeHtml(text) {
        if (!text) return '';
        const div = document.createElement('div');
        div.textContent = String(text);
        return div.innerHTML;
    }

    function escapeAttr(text) {
        return escapeHtml(text).replace(/"/g, '&quot;').replace(/'/g, '&#39;');
    }

    async function setBaseline() {
        try {
            const response = await fetch('/api/bluetooth/baseline/set', { method: 'POST' });
            const data = await response.json();

            if (data.status === 'success') {
                baselineSet = true;
                baselineCount = data.device_count;
                updateBaselineStatus();
            }
        } catch (err) {
            console.error('Failed to set baseline:', err);
            reportActionableError('Set Baseline', err, {
                onRetry: () => setBaseline()
            });
        }
    }

    async function clearBaseline() {
        try {
            const response = await fetch('/api/bluetooth/baseline/clear', { method: 'POST' });
            const data = await response.json();

            if (data.status === 'success') {
                baselineSet = false;
                baselineCount = 0;
                updateBaselineStatus();
            }
        } catch (err) {
            console.error('Failed to clear baseline:', err);
            reportActionableError('Clear Baseline', err, {
                onRetry: () => clearBaseline()
            });
        }
    }

    function updateBaselineStatus() {
        if (!baselineStatusEl) return;

        if (baselineSet) {
            baselineStatusEl.textContent = `Baseline: ${baselineCount} devices`;
            baselineStatusEl.style.color = '#22c55e';
        } else {
            baselineStatusEl.textContent = 'No baseline';
            baselineStatusEl.style.color = '';
        }
    }

    function exportData(format) {
        window.open(`/api/bluetooth/export?format=${format}`, '_blank');
    }

    function showErrorMessage(message) {
        console.error('[BT] Error:', message);
        if (typeof showNotification === 'function') {
            showNotification('Bluetooth Error', message, 'error');
        }
    }

    function showInfo(message) {
        console.log('[BT]', message);
        if (typeof showNotification === 'function') {
            showNotification('Bluetooth', message, 'info');
        }
    }

    /**
     * Toggle the service data inspector panel
     */
    function toggleServiceInspector() {
        const content = document.getElementById('btInspectorContent');
        const arrow = document.getElementById('btInspectorArrow');
        if (!content) return;
        const open = content.style.display === 'none';
        content.style.display = open ? '' : 'none';
        if (arrow) arrow.classList.toggle('open', open);
    }

    // ==========================================================================
    // Agent Handling
    // ==========================================================================

    /**
     * Handle agent change - refresh adapters and optionally clear data.
     */
    function handleAgentChange() {
        const currentAgentId = typeof currentAgent !== 'undefined' ? currentAgent : 'local';

        // Check if agent actually changed
        if (lastAgentId === currentAgentId) return;

        console.log('[BT] Agent changed from', lastAgentId, 'to', currentAgentId);

        // Stop any running scan
        if (isScanning) {
            stopScan();
        }

        // Clear existing data when switching agents (unless "Show All" is enabled)
        if (!showAllAgentsMode) {
            clearData();
            showInfo(`Switched to ${getCurrentAgentName()} - previous data cleared`);
        }

        // Refresh capabilities for new agent
        checkCapabilities();

        lastAgentId = currentAgentId;
    }

    /**
     * Clear all collected data.
     */
    function clearData() {
        devices.clear();
        pendingDeviceIds.clear();
        pendingDeviceFlush = false;
        selectedDeviceNeedsRefresh = false;
        resetStats();
        clearSelection();

        if (deviceContainer) {
            if (typeof renderCollectionState === 'function') {
                renderCollectionState(deviceContainer, { type: 'empty', message: 'Start scanning to discover Bluetooth devices' });
            } else {
                deviceContainer.innerHTML = '';
            }
        }
    }

    /**
     * Toggle "Show All Agents" mode.
     */
    function toggleShowAllAgents(enabled) {
        showAllAgentsMode = enabled;
        console.log('[BT] Show all agents mode:', enabled);

        if (enabled) {
            // If currently scanning, switch to multi-agent stream
            if (isScanning && eventSource) {
                eventSource.close();
                startEventStream();
            }
            showInfo('Showing Bluetooth devices from all agents');
        } else {
            // Filter to current agent only
            filterToCurrentAgent();
        }
    }

    /**
     * Filter devices to only show those from current agent.
     */
    function filterToCurrentAgent() {
        const agentName = getCurrentAgentName();
        const toRemove = [];

        devices.forEach((device, deviceId) => {
            if (device._agent && device._agent !== agentName) {
                toRemove.push(deviceId);
            }
        });

        toRemove.forEach(deviceId => devices.delete(deviceId));

        // Re-render device list
        if (deviceContainer) {
            deviceContainer.innerHTML = '';
            devices.forEach(device => renderDevice(device, false));
            applyDeviceFilter();
            if (devices.size === 0 && typeof renderCollectionState === 'function') {
                renderCollectionState(deviceContainer, { type: 'empty', message: 'No devices for current agent' });
            }
        }

        if (selectedDeviceId && !devices.has(selectedDeviceId)) {
            clearSelection();
        }

        updateDeviceCount();
        updateStatsFromDevices();
        updateVisualizationPanels();
        updateProximityZones();
        updateRadar();
    }

    /**
     * Hand off a device to BT Locate mode by device_id lookup.
     */
    function locateById(deviceId) {
        console.log('[BT] locateById called with:', deviceId);
        const device = devices.get(deviceId);
        if (!device) {
            console.warn('[BT] Device not found in map for id:', deviceId);
            return;
        }
        doLocateHandoff(device);
    }

    /**
     * Hand off the currently selected device to BT Locate mode.
     */
    function locateDevice() {
        if (!selectedDeviceId) return;
        const device = devices.get(selectedDeviceId);
        if (!device) return;
        doLocateHandoff(device);
    }

    function doLocateHandoff(device) {
        const payload = {
            device_id: device.device_id,
            device_key: device.device_key || null,
            mac_address: device.address,
            address_type: device.address_type || null,
            irk_hex: device.irk_hex || null,
            known_name: device.name || null,
            known_manufacturer: device.manufacturer_name || null,
            last_known_rssi: device.rssi_current,
            tx_power: device.tx_power || null,
            appearance_name: device.appearance_name || null,
            fingerprint_id: device.fingerprint_id || device.fingerprint?.id || null,
            mac_cluster_count: device.mac_cluster_count || 0
        };

        // If BtLocate is already loaded, hand off directly
        if (typeof BtLocate !== 'undefined') {
            BtLocate.handoff(payload);
            return;
        }

        // Switch to bt_locate mode first — this loads the script, styles,
        // and initializes the module. Then hand off the device data.
        if (typeof switchMode === 'function') {
            switchMode('bt_locate').then(function() {
                if (typeof BtLocate !== 'undefined') {
                    BtLocate.handoff(payload);
                }
            });
        }
    }

    // Public API
    return {
        init,
        startScan,
        stopScan,
        checkCapabilities,
        setBaseline,
        clearBaseline,
        exportData,
        selectDevice,
        clearSelection,
        copyAddress,
        toggleWatchlist,
        locateDevice,
        locateById,
        toggleServiceInspector,

        // Agent handling
        handleAgentChange,
        clearData,
        toggleShowAllAgents,

        // Getters
        getDevices: () => Array.from(devices.values()),
        isScanning: () => isScanning,
        isShowAllAgents: () => showAllAgentsMode,

        // Lifecycle
        destroy
    };

    /**
     * Destroy — close SSE stream and clear polling timers for clean mode switching.
     */
    function destroy() {
        stopEventStream();
        devices.clear();
        pendingDeviceIds.clear();
        if (deviceContainer) {
            deviceContainer.innerHTML = '';
        }
        const countEl = document.getElementById('btDeviceListCount');
        if (countEl) countEl.textContent = '0';
    }
})();

// Global functions for onclick handlers
function btStartScan() { BluetoothMode.startScan(); }
function btStopScan() { BluetoothMode.stopScan(); }
function btCheckCapabilities() { BluetoothMode.checkCapabilities(); }
function btSetBaseline() { BluetoothMode.setBaseline(); }
function btClearBaseline() { BluetoothMode.clearBaseline(); }
function btExport(format) { BluetoothMode.exportData(format); }

// Initialize when DOM is ready
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', () => {
        if (document.getElementById('bluetoothMode')) {
            BluetoothMode.init();
        }
    });
} else {
    if (document.getElementById('bluetoothMode')) {
        BluetoothMode.init();
    }
}

window.BluetoothMode = BluetoothMode;