script.js

// MeshTastic覆盖范围测定软件 - JavaScript核心功能

// 全局变量
let map;
let markers = [];
let tracePoints = [];
let tracePath = null;
let distancePoints = [];
let distanceLine = null;
let isTracing = false;
let nodes = []; // 存储所有节点信息
let coverageCircles = []; // 存储覆盖范围圆

// 梅登海德坐标转换功能
class MaidenheadLocator {
    // 将经纬度转换为梅登海德坐标
    static latLngToMaidenhead(lat, lng, precision = 3) {
        // 调整经纬度到正确范围
        lat = Math.max(-90, Math.min(90, lat));
        lng = Math.max(-180, Math.min(180, lng));
        
        // 转换为正数范围
        const latPos = lat + 90;
        const lngPos = lng + 180;
        
        const locator = [];
        const fields = "ABCDEFGHIJKLMNOPQR";
        const squares = "0123456789";
        const subsquares = "ABCDEFGHIJKLMNOPQRSTUVWX";
        
        // 字段（前两个字符）
        locator.push(fields[Math.floor(lngPos / 20)]);
        locator.push(fields[Math.floor(latPos / 10)]);
        
        if (precision > 0) {
            // 正方形（接下来两个字符）
            locator.push(squares[Math.floor((lngPos % 20) / 2)]);
            locator.push(squares[Math.floor(latPos % 10)]);
            
            if (precision > 1) {
                // 子正方形（接下来两个字符）
                locator.push(subsquares[Math.floor(((lngPos % 20) % 2) * 12)]);
                locator.push(subsquares[Math.floor((latPos % 10) * 2.4)]);
                
                if (precision > 2) {
                    // 扩展子正方形（接下来两个字符）
                    locator.push(squares[Math.floor((((lngPos % 20) % 2) * 12) % 1 * 10)]);
                    locator.push(squares[Math.floor(((latPos % 10) * 2.4) % 1 * 10)]);
                }
            }
        }
        
        return locator.join("");
    }
    
    // 将梅登海德坐标转换为经纬度
    static maidenheadToLatLng(maidenhead) {
        maidenhead = maidenhead.toUpperCase().replace(/\s/g, "");
        
        if (maidenhead.length < 4) {
            throw new Error("梅登海德坐标至少需要4个字符");
        }
        
        const fields = "ABCDEFGHIJKLMNOPQR";
        const squares = "0123456789";
        const subsquares = "ABCDEFGHIJKLMNOPQRSTUVWX";
        
        let lng = fields.indexOf(maidenhead[0]) * 20 - 180;
        let lat = fields.indexOf(maidenhead[1]) * 10 - 90;
        
        lng += squares.indexOf(maidenhead[2]) * 2;
        lat += squares.indexOf(maidenhead[3]);
        
        if (maidenhead.length >= 6) {
            lng += subsquares.indexOf(maidenhead[4]) / 12;
            lat += subsquares.indexOf(maidenhead[5]) / 24;
            
            if (maidenhead.length >= 8) {
                lng += squares.indexOf(maidenhead[6]) / 120;
                lat += squares.indexOf(maidenhead[7]) / 240;
            }
        }
        
        // 调整到中心位置
        lng += 1 / 12;
        lat += 1 / 24;
        
        return { lat, lng };
    }
}

// 初始化地图
function initMap() {
    // 创建地图实例
    map = L.map('map').setView([39.9042, 116.4074], 13); // 默认北京坐标
    
    // 添加OpenStreetMap图层
    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
        attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
        maxZoom: 19
    }).addTo(map);
    
    // 添加地图点击事件，用于手动添加标记
    map.on('click', handleMapClick);
    
    // 尝试获取用户当前位置
    getCurrentLocation();
    
    // 从本地存储加载数据
    loadData();
}

// 处理地图点击事件
function handleMapClick(e) {
    // 如果正在trace，自动添加点
    if (isTracing) {
        addTracePoint(e.latlng);
    }
}

// 获取当前位置
function getCurrentLocation() {
    if (navigator.geolocation) {
        navigator.geolocation.getCurrentPosition(
            (position) => {
                const latlng = [position.coords.latitude, position.coords.longitude];
                map.setView(latlng, 15);
                
                // 在当前位置添加临时标记
                const tempMarker = L.marker(latlng).addTo(map);
                tempMarker.bindPopup("您的当前位置").openPopup();
                
                // 3秒后移除临时标记
                setTimeout(() => {
                    map.removeLayer(tempMarker);
                }, 3000);
            },
            (error) => {
                console.error("获取位置失败:", error);
                alert("无法获取您的位置，请手动选择位置");
            }
        );
    } else {
        alert("您的浏览器不支持地理定位");
    }
}

// 根据RSSI值获取信号强度等级和颜色
function getSignalStrengthInfo(rssi) {
    if (rssi >= -70) {
        return { level: 'strong', color: '#28a745', label: '强' };
    } else if (rssi >= -90) {
        return { level: 'medium', color: '#ffc107', label: '中' };
    } else {
        return { level: 'weak', color: '#dc3545', label: '弱' };
    }
}

// 添加数据标记到地图
function addDataMarker(latlng, data) {
    const signalInfo = getSignalStrengthInfo(data.rssi);
    
    // 创建自定义图标
    const icon = L.divIcon({
        className: `custom-marker marker-${signalInfo.level}`,
        html: `<div style="background-color: ${signalInfo.color}; width: 16px; height: 16px; border-radius: 50%; border: 2px solid white; box-shadow: 0 2px 5px rgba(0,0,0,0.3);"></div>`,
        iconSize: [16, 16],
        iconAnchor: [8, 8]
    });
    
    // 创建标记
    const marker = L.marker(latlng, { icon: icon }).addTo(map);
    
    // 绑定弹出窗口
    const popupContent = `
        <div class="popup-content">
            <h3>${data.nodeName || `节点 ${data.nodeId}`}</h3>
            <p><strong>信号强度:</strong> ${data.rssi} dBm (${signalInfo.label})</p>
            <p><strong>Hop数:</strong> ${data.hopCount}</p>
            <p><strong>发射功率:</strong> ${data.txPower} dBm</p>
            <p><strong>节点ID:</strong> ${data.nodeId}</p>
            <p><strong>位置:</strong> ${latlng.lat.toFixed(6)}, ${latlng.lng.toFixed(6)}</p>
            <p><strong>时间:</strong> ${new Date(data.timestamp).toLocaleString()}</p>
            ${data.comment ? `<p><strong>备注:</strong> ${data.comment}</p>` : ''}
        </div>
    `;
    marker.bindPopup(popupContent);
    
    // 保存标记和数据
    marker.data = data;
    markers.push(marker);
    
    return marker;
}

// 处理表单提交
function handleFormSubmit(e) {
    e.preventDefault();
    
    // 获取表单数据
    const formData = new FormData(e.target);
    const data = {
        rssi: parseInt(formData.get('rssi')),
        hopCount: parseInt(formData.get('hopCount')),
        txPower: parseInt(formData.get('txPower')),
        nodeId: formData.get('nodeId'),
        nodeName: formData.get('nodeName') || '',
        comment: formData.get('comment') || '',
        timestamp: Date.now()
    };
    
    // 获取当前位置或使用地图中心
    if (navigator.geolocation) {
        navigator.geolocation.getCurrentPosition(
            (position) => {
                const latlng = [position.coords.latitude, position.coords.longitude];
                addDataMarker(latlng, data);
                saveData();
                e.target.reset();
                alert('数据上传成功！');
            },
            (error) => {
                console.error("获取位置失败:", error);
                // 使用地图中心位置
                const latlng = map.getCenter();
                addDataMarker(latlng, data);
                saveData();
                e.target.reset();
                alert('数据上传成功（使用地图中心位置）！');
            }
        );
    } else {
        // 使用地图中心位置
        const latlng = map.getCenter();
        addDataMarker(latlng, data);
        saveData();
        e.target.reset();
        alert('数据上传成功（使用地图中心位置）！');
    }
}

// 获取当前位置按钮点击事件
function handleGetLocationBtnClick() {
    getCurrentLocation();
}

// 距离测定功能
function handleStartDistanceBtnClick() {
    distancePoints = [];
    if (distanceLine) {
        map.removeLayer(distanceLine);
        distanceLine = null;
    }
    alert('点击地图标记起点位置');
    map.once('click', (e) => {
        distancePoints.push(e.latlng);
        L.marker(e.latlng, { icon: L.divIcon({ className: 'distance-marker', html: '<div style="background-color: green; width: 12px; height: 12px; border-radius: 50%; border: 2px solid white;"></div>' }) }).addTo(map);
        alert('起点已标记，点击地图标记终点位置');
        map.once('click', (e) => {
            distancePoints.push(e.latlng);
            L.marker(e.latlng, { icon: L.divIcon({ className: 'distance-marker', html: '<div style="background-color: red; width: 12px; height: 12px; border-radius: 50%; border: 2px solid white;"></div>' }) }).addTo(map);
            drawDistanceLine();
        });
    });
}

function handleEndDistanceBtnClick() {
    if (distancePoints.length === 1) {
        map.once('click', (e) => {
            distancePoints.push(e.latlng);
            L.marker(e.latlng, { icon: L.divIcon({ className: 'distance-marker', html: '<div style="background-color: red; width: 12px; height: 12px; border-radius: 50%; border: 2px solid white;"></div>' }) }).addTo(map);
            drawDistanceLine();
        });
    }
}

function drawDistanceLine() {
    if (distancePoints.length === 2) {
        if (distanceLine) {
            map.removeLayer(distanceLine);
        }
        distanceLine = L.polyline(distancePoints, { className: 'distance-line' }).addTo(map);
        calculateDistance();
    }
}

function calculateDistance() {
    if (distancePoints.length === 2) {
        const distance = map.distance(distancePoints[0], distancePoints[1]);
        const distanceKm = (distance / 1000).toFixed(3);
        const resultDiv = document.getElementById('distanceResult');
        resultDiv.innerHTML = `
            <p>两点距离: ${distanceKm} 公里</p>
            <p>起点: ${distancePoints[0].lat.toFixed(6)}, ${distancePoints[0].lng.toFixed(6)}</p>
            <p>终点: ${distancePoints[1].lat.toFixed(6)}, ${distancePoints[1].lng.toFixed(6)}</p>
        `;
    }
}

function handleCalculateDistanceBtnClick() {
    calculateDistance();
}

// Trace路径功能
function handleStartTraceBtnClick() {
    isTracing = true;
    tracePoints = [];
    if (tracePath) {
        map.removeLayer(tracePath);
        tracePath = null;
    }
    document.getElementById('traceStatus').textContent = '正在Trace...';
    document.getElementById('startTraceBtn').disabled = true;
    document.getElementById('stopTraceBtn').disabled = false;
    alert('Trace已开始，移动设备或点击地图添加路径点');
    
    // 开始定时获取位置
    startLocationTracking();
}

function handleStopTraceBtnClick() {
    isTracing = false;
    document.getElementById('traceStatus').textContent = '已停止';
    document.getElementById('startTraceBtn').disabled = false;
    document.getElementById('stopTraceBtn').disabled = true;
    stopLocationTracking();
    
    if (tracePoints.length > 1) {
        drawTracePath();
    }
}

function handleClearTraceBtnClick() {
    isTracing = false;
    tracePoints = [];
    if (tracePath) {
        map.removeLayer(tracePath);
        tracePath = null;
    }
    document.getElementById('traceStatus').textContent = '未开始';
    document.getElementById('traceNodeCount').textContent = '0';
    document.getElementById('startTraceBtn').disabled = false;
    document.getElementById('stopTraceBtn').disabled = true;
    stopLocationTracking();
}

function addTracePoint(latlng) {
    tracePoints.push(latlng);
    document.getElementById('traceNodeCount').textContent = tracePoints.length;
    
    // 添加临时标记
    L.circleMarker(latlng, {
        radius: 4,
        color: '#007bff',
        fillColor: '#007bff',
        fillOpacity: 0.8
    }).addTo(map);
    
    // 如果有多个点，绘制路径
    if (tracePoints.length > 1 && isTracing) {
        drawTracePath();
    }
}

function drawTracePath() {
    if (tracePath) {
        map.removeLayer(tracePath);
    }
    tracePath = L.polyline(tracePoints, { className: 'trace-path' }).addTo(map);
}

// 位置追踪
let locationTrackingInterval = null;

function startLocationTracking() {
    if (navigator.geolocation) {
        locationTrackingInterval = setInterval(() => {
            navigator.geolocation.getCurrentPosition(
                (position) => {
                    const latlng = [position.coords.latitude, position.coords.longitude];
                    addTracePoint(latlng);
                },
                (error) => {
                    console.error("位置追踪失败:", error);
                }
            );
        }, 5000); // 每5秒获取一次位置
    }
}

function stopLocationTracking() {
    if (locationTrackingInterval) {
        clearInterval(locationTrackingInterval);
        locationTrackingInterval = null;
    }
}

// Log上传功能
function handleUploadLogBtnClick() {
    const fileInput = document.getElementById('logFile');
    if (!fileInput.files.length) {
        alert('请先选择一个log文件');
        return;
    }
    
    const file = fileInput.files[0];
    const reader = new FileReader();
    
    reader.onload = function(e) {
        const content = e.target.result;
        // 这里可以添加log解析逻辑
        const resultDiv = document.getElementById('logUploadResult');
        resultDiv.innerHTML = `
            <p>文件上传成功: ${file.name}</p>
            <p>文件大小: ${(file.size / 1024).toFixed(2)} KB</p>
            <p>内容预览: ${content.substring(0, 200)}${content.length > 200 ? '...' : ''}</p>
        `;
        
        // 可以在这里解析log并在地图上显示
        parseLogContent(content);
    };
    
    reader.onerror = function() {
        alert('文件读取失败');
    };
    
    reader.readAsText(file);
}

// 解析Log内容（示例）
function parseLogContent(content) {
    // 这里可以根据实际log格式进行解析
    console.log('解析Log内容:', content);
    // 示例：假设log格式为 "lat,lng,rssi,hopCount,txPower,nodeId,timestamp"
    const lines = content.split('\n');
    lines.forEach(line => {
        if (line.trim()) {
            const parts = line.split(',');
            if (parts.length >= 7) {
                const data = {
                    rssi: parseInt(parts[2]),
                    hopCount: parseInt(parts[3]),
                    txPower: parseInt(parts[4]),
                    nodeId: parts[5],
                    timestamp: parseInt(parts[6]),
                    nodeName: '',
                    comment: ''
                };
                const latlng = [parseFloat(parts[0]), parseFloat(parts[1])];
                addDataMarker(latlng, data);
            }
        }
    });
    saveData();
}

// 数据管理功能
function handleClearAllBtnClick() {
    if (confirm('确定要清除所有数据吗？此操作不可恢复。')) {
        // 移除所有标记
        markers.forEach(marker => map.removeLayer(marker));
        markers = [];
        
        // 清除trace数据
        handleClearTraceBtnClick();
        
        // 清除距离数据
        distancePoints = [];
        if (distanceLine) {
            map.removeLayer(distanceLine);
            distanceLine = null;
        }
        document.getElementById('distanceResult').innerHTML = '';
        
        // 清除本地存储
        localStorage.removeItem('meshTasticData');
        localStorage.removeItem('meshTasticTrace');
        
        alert('所有数据已清除');
    }
}

function handleExportDataBtnClick() {
    const exportData = {
        markers: markers.map(marker => ({
            latlng: marker.getLatLng(),
            data: marker.data
        })),
        tracePoints: tracePoints,
        timestamp: Date.now()
    };
    
    const dataStr = JSON.stringify(exportData, null, 2);
    const dataBlob = new Blob([dataStr], { type: 'application/json' });
    const url = URL.createObjectURL(dataBlob);
    const link = document.createElement('a');
    link.href = url;
    link.download = `meshtastic_data_${new Date().toISOString().slice(0, 19)}.json`;
    link.click();
    URL.revokeObjectURL(url);
}

// 本地存储功能
function saveData() {
    const saveData = {
        markers: markers.map(marker => ({
            latlng: marker.getLatLng(),
            data: marker.data
        })),
        tracePoints: tracePoints
    };
    localStorage.setItem('meshTasticData', JSON.stringify(saveData));
}

function loadData() {
    const savedData = localStorage.getItem('meshTasticData');
    if (savedData) {
        const data = JSON.parse(savedData);
        
        // 加载标记
        if (data.markers) {
            data.markers.forEach(item => {
                addDataMarker(item.latlng, item.data);
            });
        }
        
        // 加载trace数据
        if (data.tracePoints && data.tracePoints.length > 0) {
            tracePoints = data.tracePoints;
            document.getElementById('traceNodeCount').textContent = tracePoints.length;
            if (tracePoints.length > 1) {
                drawTracePath();
            }
        }
    }
}

// 更新坐标显示
function updateCoordinateDisplay(lat, lng) {
    if (lat && lng) {
        const latLngStr = `${lat.toFixed(6)}, ${lng.toFixed(6)}`;
        const maidenhead = MaidenheadLocator.latLngToMaidenhead(lat, lng);
        
        document.getElementById('currentLatLng').textContent = latLngStr;
        document.getElementById('currentMaidenhead').textContent = maidenhead;
    }
}

// 节点管理功能
function initNodeManagement() {
    // 节点切换按钮
    document.getElementById('viewNodesBtn').addEventListener('click', () => {
        document.getElementById('viewNodesBtn').classList.add('active');
        document.getElementById('addNodeBtn').classList.remove('active');
        document.getElementById('nodeList').style.display = 'block';
        document.getElementById('addNodeForm').style.display = 'none';
        renderNodeList();
    });
    
    document.getElementById('addNodeBtn').addEventListener('click', () => {
        document.getElementById('addNodeBtn').classList.add('active');
        document.getElementById('viewNodesBtn').classList.remove('active');
        document.getElementById('nodeList').style.display = 'none';
        document.getElementById('addNodeForm').style.display = 'block';
    });
    
    // 节点表单提交
    document.getElementById('nodeForm').addEventListener('submit', handleNodeFormSubmit);
    
    // 使用地图中心位置
    document.getElementById('useMapLocationBtn').addEventListener('click', () => {
        const center = map.getCenter();
        document.getElementById('newLat').value = center.lat.toFixed(6);
        document.getElementById('newLng').value = center.lng.toFixed(6);
        document.getElementById('newMaidenhead').value = MaidenheadLocator.latLngToMaidenhead(center.lat, center.lng);
    });
    
    // 使用当前位置
    document.getElementById('useCurrentLocationBtn').addEventListener('click', () => {
        if (navigator.geolocation) {
            navigator.geolocation.getCurrentPosition(
                (position) => {
                    const lat = position.coords.latitude;
                    const lng = position.coords.longitude;
                    document.getElementById('newLat').value = lat.toFixed(6);
                    document.getElementById('newLng').value = lng.toFixed(6);
                    document.getElementById('newMaidenhead').value = MaidenheadLocator.latLngToMaidenhead(lat, lng);
                },
                () => {
                    alert('无法获取当前位置');
                }
            );
        }
    });
    
    // 梅登海德坐标输入事件
    document.getElementById('newMaidenhead').addEventListener('change', (e) => {
        try {
            const coords = MaidenheadLocator.maidenheadToLatLng(e.target.value);
            document.getElementById('newLat').value = coords.lat.toFixed(6);
            document.getElementById('newLng').value = coords.lng.toFixed(6);
        } catch (error) {
            console.error('无效的梅登海德坐标:', error);
        }
    });
    
    // 经纬度输入事件
    document.getElementById('newLat').addEventListener('change', updateMaidenheadFromLatLng);
    document.getElementById('newLng').addEventListener('change', updateMaidenheadFromLatLng);
}

// 从经纬度更新梅登海德坐标
function updateMaidenheadFromLatLng() {
    const lat = parseFloat(document.getElementById('newLat').value);
    const lng = parseFloat(document.getElementById('newLng').value);
    
    if (!isNaN(lat) && !isNaN(lng)) {
        const maidenhead = MaidenheadLocator.latLngToMaidenhead(lat, lng);
        document.getElementById('newMaidenhead').value = maidenhead;
    }
}

// 处理节点表单提交
function handleNodeFormSubmit(e) {
    e.preventDefault();
    
    const formData = new FormData(e.target);
    const node = {
        id: Date.now().toString(),
        nodeId: formData.get('nodeId'),
        nodeName: formData.get('nodeName'),
        lat: parseFloat(formData.get('lat')),
        lng: parseFloat(formData.get('lng')),
        altitude: parseFloat(formData.get('altitude') || 0),
        coverage: parseFloat(formData.get('coverage') || 5),
        txPower: parseFloat(formData.get('txPower') || 20),
        maidenhead: formData.get('maidenhead'),
        tested: false, // 默认未测定
        createdAt: Date.now()
    };
    
    // 如果没有梅登海德坐标，自动生成
    if (!node.maidenhead && !isNaN(node.lat) && !isNaN(node.lng)) {
        node.maidenhead = MaidenheadLocator.latLngToMaidenhead(node.lat, node.lng);
    }
    
    // 添加节点
    nodes.push(node);
    
    // 在地图上添加节点标记
    addNodeMarker(node);
    
    // 保存数据
    saveNodes();
    
    // 重置表单
    e.target.reset();
    
    // 切换回节点列表
    document.getElementById('viewNodesBtn').click();
    
    alert('节点添加成功！');
}

// 在地图上添加节点标记
function addNodeMarker(node) {
    let marker;
    
    if (node.tested) {
        // 已测定节点使用普通标记
        marker = L.marker([node.lat, node.lng]).addTo(map);
    } else {
        // 未测定节点使用汉字标记"未测定"
        marker = L.marker([node.lat, node.lng], {
            icon: L.divIcon({
                className: 'untested-marker',
                html: '未测定',
                iconSize: [60, 24],
                iconAnchor: [30, 12]
            })
        }).addTo(map);
    }
    
    // 绑定弹出窗口
    const popupContent = `
        <div class="popup-content">
            <h3>${node.nodeName || `节点 ${node.nodeId}`}</h3>
            <p><strong>Node ID:</strong> ${node.nodeId}</p>
            <p><strong>位置:</strong> ${node.lat.toFixed(6)}, ${node.lng.toFixed(6)}</p>
            <p><strong>梅登海德:</strong> ${node.maidenhead}</p>
            <p><strong>高度:</strong> ${node.altitude} m</p>
            <p><strong>发射功率:</strong> ${node.txPower} dBm</p>
            <p><strong>覆盖范围:</strong> ${node.coverage} km</p>
            <p><strong>状态:</strong> ${node.tested ? '已测定' : '未测定'}</p>
            <button onclick="toggleNodeCoverage('${node.id}')" class="btn btn-sm btn-primary">
                显示覆盖范围
            </button>
        </div>
    `;
    marker.bindPopup(popupContent);
    
    // 保存节点引用
    marker.nodeId = node.id;
    
    return marker;
}

// 渲染节点列表
function renderNodeList() {
    const nodeList = document.getElementById('nodeList');
    nodeList.innerHTML = '';
    
    if (nodes.length === 0) {
        nodeList.innerHTML = '<p style="color: var(--text-secondary); text-align: center; padding: 1rem;">暂无节点</p>';
        return;
    }
    
    nodes.forEach(node => {
        const nodeItem = document.createElement('div');
        nodeItem.className = 'node-item';
        nodeItem.innerHTML = `
            <h3>${node.nodeName || `节点 ${node.nodeId}`}</h3>
            <p><strong>ID:</strong> ${node.nodeId}</p>
            <p><strong>位置:</strong> ${node.lat.toFixed(6)}, ${node.lng.toFixed(6)}</p>
            <p><strong>梅登海德:</strong> ${node.maidenhead}</p>
            <p><strong>覆盖范围:</strong> ${node.coverage} km</p>
            <p><strong>状态:</strong> <span style="color: ${node.tested ? 'var(--success)' : 'var(--danger)'}">${node.tested ? '已测定' : '未测定'}</span></p>
        `;
        
        // 点击节点项，在地图上显示该节点
        nodeItem.addEventListener('click', () => {
            // 移除其他节点的选中状态
            document.querySelectorAll('.node-item').forEach(item => item.classList.remove('selected'));
            // 添加当前节点的选中状态
            nodeItem.classList.add('selected');
            
            // 定位到该节点
            map.setView([node.lat, node.lng], 15);
            
            // 显示覆盖范围
            showNodeCoverage(node);
        });
        
        nodeList.appendChild(nodeItem);
    });
}

// 显示节点覆盖范围
function showNodeCoverage(node) {
    // 清除现有覆盖范围
    clearCoverageCircles();
    
    // 创建覆盖范围圆
    const circle = L.circle([node.lat, node.lng], {
        radius: node.coverage * 1000, // 转换为米
        className: 'coverage-circle'
    }).addTo(map);
    
    // 添加弹出窗口
    circle.bindPopup(`
        <div>
            <h4>${node.nodeName || `节点 ${node.nodeId}`} 覆盖范围</h4>
            <p>半径: ${node.coverage} km</p>
            <p>发射功率: ${node.txPower} dBm</p>
        </div>
    `);
    
    coverageCircles.push(circle);
}

// 切换节点覆盖范围显示
function toggleNodeCoverage(nodeId) {
    const node = nodes.find(n => n.id === nodeId);
    if (node) {
        showNodeCoverage(node);
    }
}

// 清除所有覆盖范围圆
function clearCoverageCircles() {
    coverageCircles.forEach(circle => map.removeLayer(circle));
    coverageCircles = [];
}

// 显示所有节点的覆盖范围
function showAllCoverage() {
    clearCoverageCircles();
    
    const radius = parseFloat(document.getElementById('coverageRadius').value) || 5;
    const color = document.getElementById('coverageColor').value || '#007AFF';
    
    nodes.forEach(node => {
        const circle = L.circle([node.lat, node.lng], {
            radius: radius * 1000, // 转换为米
            className: 'coverage-circle',
            color: color,
            fillColor: color,
            fillOpacity: 0.1
        }).addTo(map);
        
        circle.bindPopup(`
            <div>
                <h4>${node.nodeName || `节点 ${node.nodeId}`} 覆盖范围</h4>
                <p>半径: ${radius} km</p>
                <p>发射功率: ${node.txPower} dBm</p>
            </div>
        `);
        
        coverageCircles.push(circle);
    });
}

// 初始化覆盖范围控制
function initCoverageControls() {
    document.getElementById('showCoverageBtn').addEventListener('click', showAllCoverage);
    document.getElementById('hideCoverageBtn').addEventListener('click', clearCoverageCircles);
}

// 保存节点数据到本地存储
function saveNodes() {
    localStorage.setItem('meshTasticNodes', JSON.stringify(nodes));
}

// 从本地存储加载节点数据
function loadNodes() {
    const savedNodes = localStorage.getItem('meshTasticNodes');
    if (savedNodes) {
        nodes = JSON.parse(savedNodes);
        // 在地图上添加所有节点标记
        nodes.forEach(node => addNodeMarker(node));
    }
}

// 更新地图中心点坐标显示
function updateMapCenterDisplay() {
    map.on('move', () => {
        const center = map.getCenter();
        updateCoordinateDisplay(center.lat, center.lng);
    });
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    // 初始化地图
    initMap();
    
    // 初始化节点管理
    initNodeManagement();
    
    // 初始化覆盖范围控制
    initCoverageControls();
    
    // 更新地图中心点坐标显示
    updateMapCenterDisplay();
    
    // 绑定表单事件
    const dataForm = document.getElementById('dataForm');
    dataForm.addEventListener('submit', handleFormSubmit);
    
    // 绑定按钮事件
    document.getElementById('getLocationBtn').addEventListener('click', handleGetLocationBtnClick);
    
    // 距离测定按钮
    document.getElementById('startDistanceBtn').addEventListener('click', handleStartDistanceBtnClick);
    document.getElementById('endDistanceBtn').addEventListener('click', handleEndDistanceBtnClick);
    document.getElementById('calculateDistanceBtn').addEventListener('click', handleCalculateDistanceBtnClick);
    
    // Trace路径按钮
    document.getElementById('startTraceBtn').addEventListener('click', handleStartTraceBtnClick);
    document.getElementById('stopTraceBtn').addEventListener('click', handleStopTraceBtnClick);
    document.getElementById('clearTraceBtn').addEventListener('click', handleClearTraceBtnClick);
    
    // Log上传按钮
    document.getElementById('uploadLogBtn').addEventListener('click', handleUploadLogBtnClick);
    
    // 数据管理按钮
    document.getElementById('clearAllBtn').addEventListener('click', handleClearAllBtnClick);
    document.getElementById('exportDataBtn').addEventListener('click', handleExportDataBtnClick);
    
    // 加载节点数据
    loadNodes();
    
    // 初始渲染节点列表
    renderNodeList();
});

// 辅助函数：格式化时间
function formatTime(timestamp) {
    return new Date(timestamp).toLocaleString();
}

// 辅助函数：计算两点之间的距离（Haversine公式）
function calculateHaversineDistance(lat1, lon1, lat2, lon2) {
    const R = 6371; // 地球半径（公里）
    const dLat = deg2rad(lat2 - lat1);
    const dLon = deg2rad(lon2 - lon1);
    const a = 
        Math.sin(dLat/2) * Math.sin(dLat/2) +
        Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * 
        Math.sin(dLon/2) * Math.sin(dLon/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    const distance = R * c;
    return distance;
}

function deg2rad(deg) {
    return deg * (Math.PI/180);
}