import request from '@/utils/request'
import Common from '@/utils/Common.js'

// ================== 钃濈墮鍗忚灏佽绫?==================
class HBY100JProtocol {
    constructor() {
        this.deviceId = ''; // 4G 鎺ュ彛鎵€闇€鐨?deviceId
        this.isBleConnected = false;
        this.bleDeviceId = ''; // 灏忕▼搴?APP涓繛鎺ヨ摑鐗欑殑 deviceId
        
        // 钃濈墮鏈嶅姟涓庣壒寰佸€?UUID
        this.SERVICE_UUID = '0000AE30-0000-1000-8000-00805F9B34FB'; // 0xAE30
        this.WRITE_UUID = '0000AE03-0000-1000-8000-00805F9B34FB';   // 0xAE03
        this.NOTIFY_UUID = '0000AE02-0000-1000-8000-00805F9B34FB';  // 0xAE02
        
        this.onNotifyCallback = null;
        this._fileResponseResolve = null;  // 鏂囦欢涓婁紶鏃剁瓑寰呰澶?FB 05 鍝嶅簲
    }

    // 绛夊緟璁惧 FB 05 鍝嶅簲锛岃秴鏃跺悗浠?resolve锛堣澶囧彲鑳戒笉鍝嶅簲姣忓寘锛?    waitForFileResponse(timeoutMs = 2000) {
        return new Promise((resolve) => {
            const timer = setTimeout(() => {
                if (this._fileResponseResolve) {
                    this._fileResponseResolve = null;
                    resolve(null);
                }
            }, timeoutMs);
            this._fileResponseResolve = (result) => {
                clearTimeout(timer);
                this._fileResponseResolve = null;
                resolve(result);
            };
        });
    }

    setBleConnectionStatus(status, bleDeviceId = '') {
        this.isBleConnected = status;
        if (bleDeviceId) {
            this.bleDeviceId = bleDeviceId;
        }
    }

    onNotify(callback) {
        this.onNotifyCallback = callback;
    }

    parseBleData(buffer) {
        const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
        if (view.length < 3) return null;
        
        const header = view[0];
        const tail = view[view.length - 1];
        
        // 5.1 杩炴帴钃濈墮璁惧涓诲姩涓婃姤 MAC 鍦板潃: FC + 6瀛楄妭MAC + FF
        if (header === 0xFC && tail === 0xFF && view.length >= 8) {
            const macBytes = view.slice(1, 7);
            const macAddress = Array.from(macBytes).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(':');
            const result = { type: 'mac', macAddress };
            console.log('[100J-钃濈墮] 璁惧涓婃姤MAC:', macAddress, '鍘熷:', Array.from(view).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' '));
            if (this.onNotifyCallback) this.onNotifyCallback(result);
            return result;
        }
        
        if (header !== 0xFB || tail !== 0xFF) return null; // 鏍￠獙澶村熬
        
        const funcCode = view[1];
        const data = view.slice(2, view.length - 1);
        const hexStr = Array.from(view).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
        
        let result = { funcCode, rawData: data };
        
        switch (funcCode) {
            case 0x01: result.resetType = data[0]; break;
            case 0x02: break;
            case 0x03:
                // 5.4 鑾峰彇璁惧浣嶇疆锛氱粡搴?B+绾害8B 鍧囦负 float64锛岃澶囦富鍔ㄤ笂鎶?1鍒嗛挓)涓庝富鍔ㄦ煡璇㈠搷搴旀牸寮忕浉鍚?                if (data.length >= 16) {
                    const lonBuf = new ArrayBuffer(8);
                    const latBuf = new ArrayBuffer(8);
                    new Uint8Array(lonBuf).set(data.slice(0, 8));
                    new Uint8Array(latBuf).set(data.slice(8, 16));
                    result.longitude = new DataView(lonBuf).getFloat64(0, true);
                    result.latitude = new DataView(latBuf).getFloat64(0, true);
                }
                break;
            case 0x05:
                // 05: 鏂囦欢鏇存柊鍝嶅簲 FB 05 [fileType] [status] FF锛宻tatus: 1=鎴愬姛 2=澶辫触
                if (data.length >= 1) result.fileType = data[0];
                if (data.length >= 2) result.fileStatus = data[1]; // 1=Success, 2=Failure
                if (this._fileResponseResolve) this._fileResponseResolve(result);
                break;
            case 0x04: 
                // 5.5 鑾峰彇璁惧鐢垫簮鐘舵€? 鐢垫睜瀹归噺8B + 鐢靛帇8B + 鐧惧垎姣?B + 杞﹁浇鐢垫簮1B + 缁埅鏃堕棿2B(鍒嗛挓)
                if (data.length >= 20) {
                    result.batteryPercentage = data[16];
                    result.vehiclePower = data[17];
                    result.batteryRemainingTime = data[18] | (data[19] << 8); // 灏忕搴忥紝鍗曚綅鍒嗛挓
                }
                break;
            case 0x06: 
                // 06: 璇煶鎾姤鍝嶅簲
                result.voiceBroadcast = data[0]; 
                break;
            case 0x09: 
                // 09: 淇敼闊抽噺鍝嶅簲
                result.volume = data[0]; 
                break;
            case 0x0A: 
                // 0A: 鐖嗛棯妯″紡鍝嶅簲
                result.strobeEnable = data[0];
                result.strobeMode = data[1];
                break;
            case 0x0B: 
                // 0B: 淇敼璀︾ず鐏垎闂鐜囧搷搴?                result.strobeFrequency = data[0]; 
                break;
            case 0x0C: 
                // 0C: 寮哄埗澹板厜鎶ヨ鍝嶅簲
                result.alarmEnable = data[0];
                result.alarmMode = data[1];
                break;
            case 0x0D: 
                // 0D: 璀︾ず鐏?LED 浜害璋冭妭鍝嶅簲
                result.redBrightness = data[0];
                result.blueBrightness = data[1];
                result.yellowBrightness = data[2];
                break;
            case 0x0E: 
                // 0E: 鑾峰彇褰撳墠宸ヤ綔鏂瑰紡鍝嶅簲
                result.voiceBroadcast = data[0];
                result.alarmEnable = data[1];
                result.alarmMode = data[2];
                result.strobeEnable = data[3];
                result.strobeMode = data[4];
                result.strobeFrequency = data[5];
                result.volume = data[6];
                result.redBrightness = data[7];
                result.blueBrightness = data[8];
                result.yellowBrightness = data[9];
                break;
        }
        
        const funcNames = { 0x01: '澶嶄綅', 0x02: '鍩虹淇℃伅', 0x03: '浣嶇疆', 0x04: '鐢垫簮鐘舵€?, 0x05: '鏂囦欢鏇存柊', 0x06: '璇煶鎾姤', 0x09: '闊抽噺', 0x0A: '鐖嗛棯妯″紡', 0x0B: '鐖嗛棯棰戠巼', 0x0C: '寮哄埗鎶ヨ', 0x0D: 'LED浜害', 0x0E: '宸ヤ綔鏂瑰紡' };
        const name = funcNames[funcCode] || ('0x' + funcCode.toString(16));
        console.log('[100J-钃濈墮] 璁惧鍝嶅簲 FB:', name, '瑙ｆ瀽:', JSON.stringify(result), '鍘熷:', hexStr);
        
        if (this.onNotifyCallback) {
            this.onNotifyCallback(result);
        }
        return result;
    }

    sendBleData(funcCode, dataBytes = []) {
        return new Promise((resolve, reject) => {
            if (!this.isBleConnected || !this.bleDeviceId) {
                return reject(new Error('钃濈墮鏈繛鎺?));
            }
            
            const buffer = new ArrayBuffer(dataBytes.length + 3);
            const view = new Uint8Array(buffer);
            view[0] = 0xFA; // 鏁版嵁澶?            view[1] = funcCode; // 鍔熻兘鐮?            for (let i = 0; i < dataBytes.length; i++) {
                view[2 + i] = dataBytes[i];
            }
            view[view.length - 1] = 0xFF; // 缁撳熬
            const sendHex = Array.from(view).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
            console.log('[100J-钃濈墮] 涓嬪彂鎸囦护 FA:', '0x' + funcCode.toString(16).toUpperCase(), sendHex);
            
            // 浣跨敤椤圭洰涓粺涓€鐨?BleHelper 鍙戦€佹暟鎹?            import('@/utils/BleHelper.js').then(module => {
                const bleTool = module.default.getBleTool();
                bleTool.sendData(this.bleDeviceId, buffer, this.SERVICE_UUID, this.WRITE_UUID)
                    .then(res => resolve(res))
                    .catch(err => reject(err));
            });
        });
    }

    // 绾摑鐗欐寚浠ゅ彂閫佹柟娉?    deviceReset(type = 0) { return this.sendBleData(0x01, [type]); }
    getBasicInfo() { return this.sendBleData(0x02, []); }
    getLocation() { return this.sendBleData(0x03, []); }
    getPowerStatus() { return this.sendBleData(0x04, []); }
    setVoiceBroadcast(enable) { return this.sendBleData(0x06, [enable]); }
    setVolume(volume) { return this.sendBleData(0x09, [volume]); }
    setStrobeMode(enable, mode) { return this.sendBleData(0x0A, [enable, mode]); }
    setStrobeFrequency(frequency) { return this.sendBleData(0x0B, [frequency]); }
    setForceAlarm(enable, mode) { return this.sendBleData(0x0C, [enable, mode]); }
    setLightBrightness(red, blue = 0, yellow = 0) { return this.sendBleData(0x0D, [red, blue, yellow]); }
    getCurrentWorkMode() { return this.sendBleData(0x0E, []); }

    // 0x05 鏂囦欢涓婁紶锛氬垎鐗囦紶杈擄紝鍗忚 FA 05 [fileType] [phase] [data...] FF
    // fileType: 1=璇煶 2=鍥剧墖 3=鍔ㄥ浘 4=OTA
    // phase: 0=寮€濮?1=鏁版嵁 2=缁撴潫
    // 姣忓寘鏈€澶у瓧鑺?钃濈墮锛欳HUNK_SIZE=500
    // 鏀寔 fileUrl(闇€缃戠粶涓嬭浇) 鎴?localPath(鏃犵綉缁滄椂鏈湴鏂囦欢)
    uploadVoiceFileBle(fileUrlOrLocalPath, fileType = 1, onProgress) {
        const CHUNK_SIZE = 500; // 姣忓寘鏈夋晥鏁版嵁锛屽弬鑰?6155 deviceDetail.vue
        return new Promise((resolve, reject) => {
            if (!this.isBleConnected || !this.bleDeviceId) {
                return reject(new Error('钃濈墮鏈繛鎺?));
            }
            if (!fileUrlOrLocalPath) {
                return reject(new Error('缂哄皯鏂囦欢鍦板潃鎴栨湰鍦拌矾寰?));
            }
            const isLocalPath = !/^https?:\/\//i.test(fileUrlOrLocalPath);
            if (onProgress) onProgress(1);
            const readFromPath = (path) => {
                const doSend = (bytes) => {
                    this._sendVoiceChunks(bytes, fileType, CHUNK_SIZE, onProgress)
                        .then(resolve).catch(reject);
                };
                // App 绔?getFileSystemManager 鏈疄鐜帮紝鐩存帴鐢?plus.io.requestFileSystem+getFile
                readFromPathPlus(path, doSend, reject);
            };
            const readFileEntry = (entry, doSend, reject) => {
                entry.file((file) => {
                    const reader = new plus.io.FileReader();
                    reader.onloadend = (e) => {
                        try {
                            const buf = e.target.result;
                            const bytes = new Uint8Array(buf);
                            doSend(bytes);
                        } catch (err) {
                            console.error('[100J-钃濈墮] 璇诲彇ArrayBuffer寮傚父:', err);
                            reject(err);
                        }
                    };
                    reader.onerror = () => reject(new Error('璇诲彇鏂囦欢澶辫触'));
                    reader.readAsArrayBuffer(file);
                }, (err) => reject(err));
            };
            const readFromPathPlus = (path, doSend, reject) => {
                if (typeof plus === 'undefined' || !plus.io) {
                    console.error('[100J-钃濈墮] 褰撳墠鐜涓嶆敮鎸佹枃浠惰鍙?plus.io)');
                    reject(new Error('褰撳墠鐜涓嶆敮鎸佹枃浠惰鍙?));
                    return;
                }
                // _downloads/ 鐢?requestFileSystem+getFile锛堥伩鍏?resolveLocalFileSystemURL 鍗′綇锛?                if (path && path.startsWith('_downloads/')) {
                    const fileName = path.replace(/^_downloads\//, '');
                    plus.io.requestFileSystem(plus.io.PUBLIC_DOWNLOADS, (fs) => {
                        fs.root.getFile(fileName, {}, (entry) => readFileEntry(entry, doSend, reject), (err) => reject(err));
                    }, (err) => reject(err));
                    return;
                }
                // _doc/ 鐢?requestFileSystem(PRIVATE_DOC)锛岄€愮骇 getDirectory 鍐?getFile锛堝祵濂楄矾寰勫吋瀹癸級
                if (path && path.startsWith('_doc/')) {
                    const relPath = path.replace(/^_doc\//, '');
                    const parts = relPath.split('/');
                    const fileName = parts.pop();
                    const dirs = parts;
                    plus.io.requestFileSystem(plus.io.PRIVATE_DOC, (fs) => {
                        let cur = fs.root;
                        const next = (i) => {
                            if (i >= dirs.length) {
                                cur.getFile(fileName, { create: false }, (entry) => readFileEntry(entry, doSend, reject), (err) => reject(err));
                                return;
                            }
                            cur.getDirectory(dirs[i], { create: false }, (dir) => { cur = dir; next(i + 1); }, (err) => reject(err));
                        };
                        next(0);
                    }, (err) => reject(err));
                    return;
                }
                // 鍏朵粬璺緞鍏滃簳
                let resolvePath = path;
                if (path && path.startsWith('/') && !path.startsWith('file://')) resolvePath = 'file://' + path;
                plus.io.resolveLocalFileSystemURL(resolvePath, (entry) => readFileEntry(entry, doSend, reject), (err) => reject(err));
            };
            if (isLocalPath) {
                // 鏈湴璺緞锛氭棤缃戠粶鏃剁洿鎺ヨ鍙?                readFromPath(fileUrlOrLocalPath);
            } else {
                // 缃戠粶 URL锛氫紭鍏堢敤 uni.request 鐩存帴鎷夊彇 ArrayBuffer锛堢被浼?100 璁惧锛屾棤鏂囦欢 IO锛夛紝澶辫触鍐嶈蛋 downloadFile
                let fetchUrl = fileUrlOrLocalPath;
                if (fetchUrl.startsWith('http://')) fetchUrl = 'https://' + fetchUrl.slice(7);
                uni.request({
                    url: fetchUrl,
                    method: 'GET',
                    responseType: 'arraybuffer',
                    timeout: 60000,
                    success: (res) => {
                        if (res.statusCode === 200 && res.data) {
                            const bytes = res.data instanceof ArrayBuffer ? new Uint8Array(res.data) : new Uint8Array(res.data || []);
                            if (bytes.length > 0) {
                                const doSend = (b) => {
                                    this._sendVoiceChunks(b, fileType, CHUNK_SIZE, onProgress).then(resolve).catch(reject);
                                };
                                doSend(bytes);
                                return;
                            }
                        }
                        fallbackDownload();
                    },
                    fail: () => fallbackDownload()
                });
                const fallbackDownload = () => {
                    uni.downloadFile({
                        url: fetchUrl,
                        success: (res) => {
                            if (res.statusCode !== 200 || !res.tempFilePath) {
                                reject(new Error('涓嬭浇澶辫触: ' + (res.statusCode || '鏃犺矾寰?)));
                                return;
                            }
                            Common.moveFileToDownloads(res.tempFilePath).then((p) => readFromPath(p)).catch(() => readFromPath(res.tempFilePath));
                        },
                        fail: (err) => reject(err)
                    });
                };
            }
        });
    }

    _sendVoiceChunks(bytes, fileType, chunkSize, onProgress) {
        const total = bytes.length;
        const ft = (fileType & 0xFF) || 1;
        const DELAY_AFTER_START = 200;  // 寮€濮嬪寘鍚庛€佺瓑璁惧鍝嶅簲鍚庡啀鍙戠殑缂撳啿(ms)
        const DELAY_PACKET = 200;       // 鏁版嵁鍖呴棿寤舵椂(ms)锛岃澶囨敹涓嶅叏鏃堕€傚綋鍔犲ぇ
        const toHex = (arr) => Array.from(arr).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
        console.log('[100J-钃濈墮] 璇煶鏂囦欢鎬诲ぇ灏?', total, '瀛楄妭, fileType=', ft);
        if (onProgress) onProgress(0);
        const bleToolPromise = import('@/utils/BleHelper.js').then(m => m.default.getBleTool());
        const send = (dataBytes, label = '') => {
            const buf = new ArrayBuffer(dataBytes.length + 3);
            const v = new Uint8Array(buf);
            v[0] = 0xFA;
            v[1] = 0x05;
            for (let i = 0; i < dataBytes.length; i++) v[2 + i] = dataBytes[i];
            v[v.length - 1] = 0xFF;
            const hex = toHex(v);
            const preview = v.length <= 32 ? hex : hex.slice(0, 96) + '...';
            console.log(`[100J-钃濈墮] 鍙戦€?{label} 鍏?{v.length}瀛楄妭:`, preview);
            return bleToolPromise.then(ble => ble.sendData(this.bleDeviceId, buf, this.SERVICE_UUID, this.WRITE_UUID));
        };
        const delay = (ms) => new Promise(r => setTimeout(r, ms));
        // 寮€濮嬪寘: FA 05 [fileType] [phase=0] [size 4B LE] FF
        const startData = [ft, 0, total & 0xFF, (total >> 8) & 0xFF, (total >> 16) & 0xFF, (total >> 24) & 0xFF];
        const waitPromise = this.waitForFileResponse(1000);
        return send(startData, ' 寮€濮嬪寘')
            .then(() => { if (onProgress) onProgress(1); return waitPromise; })
            .then(() => { if (onProgress) onProgress(2); return delay(DELAY_AFTER_START); })
            .then(() => {
                let seq = 0;
                const sendNext = (offset) => {
                    if (offset >= total) {
                        return delay(DELAY_PACKET).then(() => send([ft, 2], ' 缁撴潫鍖?));
                    }
                    const chunk = bytes.slice(offset, Math.min(offset + chunkSize, total));
                    const chunkData = [ft, 1, seq & 0xFF, (seq >> 8) & 0xFF, ...chunk];
                    return send(chunkData, ` #${seq} 鏁版嵁鍖卄).then(() => {
                        seq++;
                        const pct = Math.round((offset + chunk.length) / total * 100);
                        if (onProgress) onProgress(Math.min(99, Math.max(3, pct)));
                        return delay(DELAY_PACKET).then(() => sendNext(offset + chunk.length));
                    });
                };
                return sendNext(0);
            })
            .then(() => delay(DELAY_PACKET))
            .then(() => {
                if (onProgress) onProgress(100);
                return { code: 200, msg: '璇煶鏂囦欢宸查€氳繃钃濈墮涓婁紶' };
            });
    }
}

// ================== 鍏ㄥ眬鍗曚緥涓庣姸鎬佺鐞?==================
const protocolInstance = new HBY100JProtocol();

// 鏆撮湶缁欓〉闈細鏇存柊钃濈墮杩炴帴鐘舵€?export function updateBleStatus(isConnected, bleDeviceId, deviceId) {
    protocolInstance.setBleConnectionStatus(isConnected, bleDeviceId);
    protocolInstance.deviceId = deviceId;
    console.log('[100J] 钃濈墮鐘舵€?', isConnected ? '宸茶繛鎺?鍚庣画鎸囦护璧拌摑鐗?' : '宸叉柇寮€(鍚庣画鎸囦护璧?G)', { bleDeviceId: bleDeviceId || '-', deviceId });
}

// 鏆撮湶缁欓〉闈細瑙ｆ瀽钃濈墮鎺ユ敹鍒扮殑鏁版嵁
export function parseBleData(buffer) {
    return protocolInstance.parseBleData(buffer);
}

// 鏆撮湶缁欓〉闈細钃濈墮杩炴帴鍚庝富鍔ㄦ媺鍙栫數婧愮姸鎬?鐢甸噺銆佺画鑸?
export function fetchBlePowerStatus() {
    if (!protocolInstance.isBleConnected) return Promise.reject(new Error('钃濈墮鏈繛鎺?));
    console.log('[100J-钃濈墮] 鎷夊彇鐢垫簮鐘舵€?宸查€氳繃钃濈墮鍙戦€?FA 04 FF');
    return protocolInstance.getPowerStatus();
}

// 鏆撮湶缁欓〉闈細钃濈墮杩炴帴鍚庝富鍔ㄦ媺鍙栧畾浣?浼樺厛钃濈墮锛岃澶囦篃浼氭瘡1鍒嗛挓涓诲姩涓婃姤)
export function fetchBleLocation() {
    if (!protocolInstance.isBleConnected) return Promise.reject(new Error('钃濈墮鏈繛鎺?));
    console.log('[100J-钃濈墮] 鎷夊彇瀹氫綅 宸查€氳繃钃濈墮鍙戦€?FA 03 FF');
    return protocolInstance.getLocation();
}

// 鏆撮湶缁欓〉闈細灏濊瘯閲嶈繛钃濈墮(浼樺厛绛栫暐锛氭柇绾垮悗鍙戞寚浠ゅ墠鍏堝皾璇曢噸杩?
export function tryReconnectBle(timeoutMs = 2500) {
    if (protocolInstance.isBleConnected) return Promise.resolve(true);
    if (!protocolInstance.bleDeviceId) return Promise.resolve(false);
    return new Promise((resolve) => {
        import('@/utils/BleHelper.js').then(module => {
            const bleTool = module.default.getBleTool();
            const deviceId = protocolInstance.bleDeviceId;
            const f = bleTool.data.LinkedList.find(v => v.deviceId === deviceId);
            if (!f) {
                resolve(false);
                return;
            }
            const svc = f.writeServiceId || '0000AE30-0000-1000-8000-00805F9B34FB';
            const write = f.wirteCharactId || '0000AE03-0000-1000-8000-00805F9B34FB';
            const notify = f.notifyCharactId || '0000AE02-0000-1000-8000-00805F9B34FB';
            const timer = setTimeout(() => {
                resolve(protocolInstance.isBleConnected);
            }, timeoutMs);
            console.log('[100J] 钃濈墮浼樺厛锛氬皾璇曢噸杩?, deviceId);
            bleTool.LinkBlue(deviceId, svc, write, notify, 1).then(() => {
                clearTimeout(timer);
                protocolInstance.setBleConnectionStatus(true, deviceId);
                console.log('[100J] 钃濈墮閲嶈繛鎴愬姛');
                resolve(true);
            }).catch(() => {
                clearTimeout(timer);
                resolve(false);
            });
        });
    });
}

// ================== API 鎺ュ彛 (鎷︽埅灞? ==================

// 鑾峰彇璇煶绠＄悊鍒楄〃
export function deviceVoliceList(params) {
  return request({
    url: `/app/video/queryAudioFileList`,
    method: 'get',
	data:params
  })
}
// 閲嶅懡鍚?export function videRenameAudioFile(data) {
  return request({
    url: `/app/video/renameAudioFile`,
    method: 'post',
	data:data
  })
}
// 鍒犻櫎璇煶鏂囦欢鍒楄〃
export function deviceDeleteAudioFile(params) {
  return request({
    url: `/app/video/deleteAudioFile`,
    method: 'get',
	data:params
  })
}

// 鏇存柊璇煶/浣跨敤璇煶锛氳摑鐗欎紭鍏堬紝4G 鍏滃簳锛堜笉褰卞搷鍘熸湁 4G 闊抽涓嬪彂锛?// 鏈?fileUrl 鎴?localPath 涓旇摑鐗欏彲鐢ㄦ椂璧拌摑鐗欙紱鍚﹀垯鎴栬摑鐗欏け璐ユ椂璧?4G锛堜笌鍘熷厛閫昏緫涓€鑷达級
export function deviceUpdateVoice(data) {
  const httpExec = () => request({
    url: `/app/hby100j/device/updateVoice`,
    method: 'post',
    data: { id: data.id }
  });
  const localPath = data.localPath;
  const fileUrl = data.fileUrl;
  const hasLocalPath = localPath && typeof localPath === 'string' && localPath.length > 0;
  const hasFileUrl = fileUrl && typeof fileUrl === 'string' && fileUrl.length > 0;
  const fileSource = hasLocalPath ? localPath : (hasFileUrl ? fileUrl : null);
  if (!fileSource) {
    return httpExec(); // 鏃犳枃浠舵簮锛氱洿鎺?4G锛堝師鏈夐€昏緫锛?  }
  const bleExec = () => protocolInstance.uploadVoiceFileBle(fileSource, 1, data.onProgress);
  return execWithBleFirst(bleExec, httpExec, '璇煶鏂囦欢涓婁紶');
}
// 100J淇℃伅
export function deviceDetail(id) {
  return request({
    url: `/app/hby100j/device/${id}`,
    method: 'get',
  })
}

// 钃濈墮浼樺厛銆?G 鍏滃簳锛氭湭杩炴帴鏃跺皾璇曢噸杩烇紱钃濈墮澶辫触鏃跺洖閫€ 4G锛堜繚鎸佸師鏈?4G 閫氳涓嶅彉锛?function execWithBleFirst(bleExec, httpExec, logName) {
  const doBle = () => bleExec().then(res => ({ ...(res || {}), _channel: 'ble' }));
  const do4G = () => httpExec().then(res => { res._channel = '4g'; return res; });
  if (protocolInstance.isBleConnected) {
    return doBle().catch(() => { console.log('[100J] 钃濈墮澶辫触锛屽洖閫€4G'); return do4G(); });
  }
  return tryReconnectBle(2500).then(reconnected => {
    return reconnected ? doBle().catch(() => { console.log('[100J] 钃濈墮澶辫触锛屽洖閫€4G'); return do4G(); }) : do4G();
  });
}

// 鐖嗛棯妯″紡
export function deviceStrobeMode(data) {
  return execWithBleFirst(
    () => protocolInstance.setStrobeMode(data.enable, data.mode).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/strobeMode`, method: 'post', data }),
    '鐖嗛棯妯″紡'
  );
}

// 寮哄埗鎶ヨ
export function deviceForceAlarmActivation(data) {
  return execWithBleFirst(
    () => protocolInstance.setForceAlarm(data.voiceStrobeAlarm, data.mode).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/forceAlarmActivation`, method: 'post', data }),
    '寮哄埗鎶ヨ'
  );
}

// 鐖嗛棯棰戠巼
export function deviceStrobeFrequency(data) {
  return execWithBleFirst(
    () => protocolInstance.setStrobeFrequency(data.frequency).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/strobeFrequency`, method: 'post', data }),
    '鐖嗛棯棰戠巼'
  );
}

// 鐏厜璋冭妭浜害
export function deviceLightAdjustment(data) {
  return execWithBleFirst(
    () => protocolInstance.setLightBrightness(data.brightness, data.brightness, data.brightness).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/lightAdjustment`, method: 'post', data }),
    '鐏厜浜害'
  );
}

// 璋冭妭闊抽噺
export function deviceUpdateVolume(data) {
  return execWithBleFirst(
    () => protocolInstance.setVolume(data.volume).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/updateVolume`, method: 'post', data }),
    '璋冭妭闊抽噺'
  );
}

// 璇煶鎾斁
export function deviceVoiceBroadcast(data) {
  return execWithBleFirst(
    () => protocolInstance.setVoiceBroadcast(data.voiceBroadcast).then(() => ({ code: 200, msg: '鎿嶄綔鎴愬姛(钃濈墮)' })),
    () => request({ url: `/app/hby100j/device/voiceBroadcast`, method: 'post', data }),
    '璇煶鎾姤'
  );
}