//
//  BluetoothManager+Function.swift
//  HDFwear
//
//  Created by daifengyi on 2023/6/27.
//

import SwiftDate


extension BluetoothManager {
    // 通用应答
    func response(frameNumber: [UInt8], messageId: [UInt8], success: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getResponseCmd(frameNumber: frameNumber, messageId: messageId, success: success)
//        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 查询设备信息
    // 0x01 设备ID
    // 0x02 设备名称
    // 0x03 设备mac地址
    // 0x04 MCU版本号
    // 0x05 电量
    // 例如[0x02, 0x03]表示查询设备名称和设备mac地址
    func queryDeviceInfo(queryItems: [UInt8], completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getQueryDeviceInfoCmd(queryItems: queryItems)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置时间
    func newSetTime(completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getTimeCmd()
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置时间格式
    func newSetTimeFormat(format: TimeFormat, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getTimeFormatCmd(format: format)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置温度单位
    func newSetTemperatureUnit(unit: TemperatureUnit, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getTemperatureUnitCmd(unit: unit)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置公英制
    func newSetDistanceUnit(unit: DistanceUnit, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getDistanceUnitCmd(unit: unit)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置抬腕唤醒
    // bool 0表示关闭，1表示打开
    func newSetWristSense(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getWristSenseCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置触摸唤醒
    // bool 0表示关闭，1表示打开
    func newSetTouchSense(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getTouchSenseCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置低电提醒
    // bool 0表示关闭，1表示打开
    func newSetLowPowerRemind(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getLowPowerRemind(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置语言
    // lan 0表示中文，1表示英语
    func newSetLanguage(lan: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getLanguageCmd(lan)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置恢复出厂设置
    func newSetRestore(completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getRestoreCmd()
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置心率过高提醒
    // maxHr 0表示关闭提醒    其他值表示最大值
    func newSetHeartRateHighRemind(maxHr: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getHeartRateHighRemindCmd(maxHr)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置心率过低提醒
    // minHr 0表示关闭提醒    其他值表示最小值
    func newSetHeartRateLowRemind(minHr: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getHeartRateLowRemindCmd(minHr)
        self.setCmdClosure = completion
        sendData(data)
    }
    // 设置安静心率预警
    // bool 0表示关闭    1表示打开
    // minHr 表示最小值
    // maxHr 表示最大值
    func newSetRestHeartRateRemind(bool:Bool, minHr: UInt8, maxHr: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getRestHeartRateRemindCmd(bool: bool, minHr: minHr, maxHr: maxHr)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置运动心率预警
    // bool 0表示关闭    1表示打开
    // minHr 表示最小值
    // maxHr 表示最大值
    func newSetExerciseHeartRateRemind(bool:Bool, minHr: UInt8, maxHr: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getExerciseHeartRateRemindCmd(bool: bool, minHr: minHr, maxHr: maxHr)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置查找手表
    // bool 0表示关闭    1表示打开
    func newSetFindWatch(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getFindWatchCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置压力自动检测
    // bool 0表示关闭    1表示打开
    func newSetPressureAutoDetect(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getPressureAutoDetectCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置血压自动检测
    // bool 0表示关闭    1表示打开
    func newSetBloodOxygenAutoDetect(bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getBloodOxygenAutoDetectCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置用户信息
    // user 使用UserInfoModel数据类型，该接口只支持身高、体重、性别、年龄的设置，对应是weight、height、gender、age
    func newSetUserInfo(_ user: UserInfoModel, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getUserInfoCmd(user)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置勿扰模式
    func newSetNotDisturb(noDisturb: NewNoDisturbModel, completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getNotDisturbCmd(noDisturb)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置天气
    //
    func newSetWeather(weather: NewWeatherModel, completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getNewWeatherCmd(weather)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置北斗联系人
    //
    func newSetBeiDouContact(contacts: [NewBeiDouContactModel], completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getNewBeiDouContactCmd(contacts)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置北斗快捷回复
    //
    func newSetBeiDouQuickAnswer(answers: [String], completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getNewBeiDouQuickAnswerCmd(answers)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 心率测量间隔设置
    func newSetHeartRateDetectInterval(bool: Bool, interval: UInt8, completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getHeartRateDetectIntervalCmd(bool: bool, interval: interval)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置血氧过低提醒
    // minBo 0表示关闭提醒    其他值表示最小值
    func newSetBloodOxygenLowRemind(minBo: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getBloodOxygenLowRemindCmd(minBo)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 设置消息提醒
    // 0表示关闭    1表示开启
    // enable 总开关   system 系统消息     wechat 微信消息     qq qq消息
    func newSetMessageRemind(enable: Bool, system: Bool, wechat: Bool, qq: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getMessageRemindCmd(enable: enable, system: system, wechat: wechat, qq: qq)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 发起运动交互
    // 这里的status 1 与文档描述有区别，与开发确认过
    // status 1、准备查看运动状态  5、运动暂停  6、运动中  7、运动结束
    func newSetExerciseStatus(status: Int, type: Int, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getExerciseStatusCmd(status: status, type: type)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    //MARK: - 同步健康数据
    //拉取数据
    func newGetData(type:SyncType, option: SyncOption = .now, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getSyncCmd(type, option)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    // 拉取电量数据
    func newGetBatteryData(option: SyncOption = .now, completion: ((_ error: Int?) -> ())? = nil) {
        newGetData(type: .battery, option: option, completion: completion)
    }
    
    // 拉取GPS轨迹数据
    func newGetGpsData(option: SyncOption = .now, closure: GpsClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.gps, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .gps)
    }
    
    // 拉取中高强度时长
    func newGetIntensiveTimeData(option: SyncOption = .now, closure: IntensiveTimeClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.intensiveTime, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .intensiveTime)
    }
    
    // 拉取北斗卡号
    func newGetBeidouCardData(option: SyncOption = .now, closure: BeidouCardClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.beidouCard, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .beidouCard)
    }
    
    // 拉取勿扰模式
    func newGetNoDisturbData(option: SyncOption = .now, closure: NoDisturbClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.noDisturb, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .noDisturb)
    }
    
    // 拉取血氧自动检测开关
    func newGetBoAutoDetectData(option: SyncOption = .now, closure: BoAutoDetectClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.boAutoDetect, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .boAutoDetect)
    }
    
    // 拉取血氧预警开关
    func newGetBoLowRemindData(option: SyncOption = .now, closure: BoLowRemindClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.boLowRemind, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .boLowRemind)
    }
    
    // 拉取心率自动检测开关
    func newGetHrAutoDetectData(option: SyncOption = .now, closure: HrAutoDetectClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.hrAutoDetect, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .hrAutoDetect)
    }
    
    // 拉取运动心率预警开关
    func newGetExerciseHrRemindData(option: SyncOption = .now, closure: ExerciseHrRemindClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.exerciseHrRemind, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .exerciseHrRemind)
    }
    
    // 拉取抬腕提醒开关
    func newGetWristSenseData(option: SyncOption = .now, closure: WristSenseClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.wristSense, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .wristSense)
    }
    
    // 拉取固件版本号
    func newGetfirmwareVersionData(option: SyncOption = .now, closure: FirmwareVersionClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.firmwareVersion, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .firmwareVersion)
    }
    
    //MARK: - old code
    // 拉取睡眠数据
    func getSleepData(option: SyncOption = .now, closure: SleepClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.sleep, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .sleep)
    }
    
    // 拉取血氧数据
    func getBloodOxygenData(option: SyncOption = .now, closure: BloodOxygenClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.bloodOxygen, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .bloodOxygen)
    }
    
    // 拉取心跳数据
    func getHeartRateData(option: SyncOption = .now, closure: HeartRateClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.heartRate, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .heartRate)
    }
    
    // 拉取步数数据
    func getStepData(option: SyncOption = .now, closure: StepClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.step, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .step)
    }
    
    // 拉取运动记录
    func getExerciseData(option: SyncOption = .now, closure: ExerciseClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.train, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .train)
    }
    
    // 拉取压力数据
    func getPressureData(option: SyncOption = .now, closure: PressureClosure? = nil) {
        let data = BleMessage.shared.getSyncCmd(.pressure, option)
        newStartSyncHealthData(closure: closure, data: data, synType: .pressure)
    }
    
    // 同步数据
    func newStartSyncHealthData(closure: Any?, data: Data, synType: SyncType) {
//        if !isSync {
//            GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncInterval", timeInterval: 0.1, queue: .main, repeats: false) {
                self.clearClosures(closure: closure, synType: synType)
//                self.startSyncTimer()
//                self.isNextSync = false
//                self.isSync = true
//                self.isSyncType = synType
                self.sendData(data)
//            }
//        } else {
//            switch closure {
//            case is BloodPressureClosure:
//                if bloodPressureClosure == nil {
//                    bloodPressureClosure = closure as? BloodPressureClosure
//                    bloodPressureClosure?([], -1002)
//                    bloodPressureClosure = nil
//                }
//            case is HeartRateClosure:
//                if heartRateClosure == nil {
//                    heartRateClosure = closure as? HeartRateClosure
//                    heartRateClosure?([], -1002)
//                    heartRateClosure = nil
//                }
//            case is BloodOxygenClosure:
//                if bloodOxygenClosure == nil {
//                    bloodOxygenClosure = closure as? BloodOxygenClosure
//                    bloodOxygenClosure?([], -1002)
//                    bloodOxygenClosure = nil
//                }
//            case is SleepClosure:
//                if sleepClosure == nil {
//                    sleepClosure = closure as? SleepClosure
//                    sleepClosure?(nil, -1002)
//                    sleepClosure = nil
//                }
//            case is StepClosure:
//                if stepClosure == nil {
//                    stepClosure = closure as? StepClosure
//                    stepClosure?([], -1002)
//                    stepClosure = nil
//                }
//            case is ExerciseClosure:
//                if exerciseClosure == nil {
//                    exerciseClosure = closure as? ExerciseClosure
//                    exerciseClosure?(nil, -1002)
//                    exerciseClosure = nil
//                }
//            case is PressureClosure:
//                if pressureClosure == nil {
//                    pressureClosure = closure as? PressureClosure
//                    pressureClosure?([], -1002)
//                    pressureClosure = nil
//                }
//            case is MettClosure:
//                if mettClosure == nil {
//                    mettClosure = closure as? MettClosure
//                    mettClosure?([], -1002)
//                    mettClosure = nil
//                }
//            case is GpsClosure:
//                if gpsClosure == nil {
//                    gpsClosure = closure as? GpsClosure
//                    gpsClosure?(nil, -1002)
//                    gpsClosure = nil
//                }
//            case is IntensiveTimeClosure:
//                if intensiveTimeClosure == nil {
//                    intensiveTimeClosure = closure as? IntensiveTimeClosure
//                    intensiveTimeClosure?(nil, -1002)
//                    intensiveTimeClosure = nil
//                }
//            case is BeidouCardClosure:
//                if beidouCardClosure == nil {
//                    beidouCardClosure = closure as? BeidouCardClosure
//                    beidouCardClosure?(nil, -1002)
//                    beidouCardClosure = nil
//                }
//            case is FirmwareVersionClosure:
//                if firmwareVersionClosure == nil {
//                    firmwareVersionClosure = closure as? FirmwareVersionClosure
//                    firmwareVersionClosure?(nil, nil, -1002)
//                    firmwareVersionClosure = nil
//                }
//            default:
//                break
//            }
//        }
    }
    //MARK: - 发送数据
    func sendData(_ data: Data) {
        taskManager.executeTaskIfNeeded { [weak self] in
            let dateFormatter = DateFormatter()
            dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
            dateFormatter.timeZone = TimeZone.current
            let currentDate = Date()
            let formattedDate = dateFormatter.string(from: currentDate)
            print("Task executed at \(formattedDate)")
            self?.coreSendData(data)
        }
    }
    
    func coreSendData(_ data: Data) {
        if peripheral == nil {
            print("peripheral == nil")
            return
        }
        
        var serverUUID: String = ""
        var writeUUID: String = ""
        switch platform {
        case ._828:
            serverUUID = BLEConfig.ServerUUID
            writeUUID = BLEConfig.WriteUUID
        default:
            break
        }
        
        if let services = peripheral?.services {
            for service in services {
//                if service.uuid.uuidString == serverUUID {
                if serverUUID.contains(service.uuid.uuidString) {
                    if service.characteristics == nil {
                        return
                    }
                    for char in service.characteristics! {
//                        if char.uuid.uuidString == writeUUID {
                        if writeUUID.contains(char.uuid.uuidString) {
                            if platform == ._828 {
//                                j!!!发送的数据长度限制
                                if data.count <= 20 {
                                    print("发送: \([UInt8](data))")
                                    peripheral?.writeValue(data, for: char, type: .withoutResponse)
                                } else {
                                    print("发送 拼: \([UInt8](data))")
                                    let n = data.count/20 + (data.count%20 == 0 ? 0 : 1)
                                    for i in 0..<n {
                                        peripheral?.writeValue(data[i*20..<min(i*20+20, data.count)], for: char, type: .withoutResponse)
                                    }
                                }
                            } else {
                            print("发送: \([UInt8](data))")
                                peripheral?.writeValue(data, for: char, type: .withResponse)
                            }
                        }
                    }
                }
            }
        }
    }
    //MARK: - 解析数据
    func parseData(_ bytes: [UInt8]) {
//        stopSyncTimer(BLEConfig.SyncHealthTimer)
//        if !isNextSync {
//            isSync = false
//            isSyncType = .other
//        }
        // debug
//        let bytes: [UInt8] = [0xED, 0x7E, 0x00, 0x01, 0x80, 0x16, 0x00, 0x07, 0x00, 0xC8, 0x64, 0x9D, 0xA3, 0xB4, 0x70, 0x64, 0x9D, 0xAA, 0xBC, 0xF7, 0x64, 0x9D, 0xB1, 0xC4, 0x06, 0x64, 0x9D, 0xB8, 0xCC, 0x00, 0x64, 0x9D, 0xBF, 0xD4, 0x16, 0x64, 0x9D, 0xC6, 0xDC, 0xF9, 0x64, 0x9D, 0xCD, 0xE4, 0x06, 0x64, 0x9D, 0xD4, 0xEC, 0x00, 0x64, 0x9D, 0xDB, 0xF4, 0x00, 0x64, 0x9D, 0xE2, 0xFC, 0xFB, 0x64, 0x9D, 0xEA, 0x04, 0x06, 0x64, 0x9D, 0xF1, 0x0C, 0x00, 0x64, 0x9D, 0xF8, 0x14, 0xE5, 0x64, 0x9D, 0xFF, 0x1C, 0xFD, 0x64, 0x9E, 0x06, 0x24, 0x06, 0x64, 0x9E, 0x0D, 0x2C, 0x00, 0x64, 0x9E, 0x14, 0x34, 0xC5, 0x64, 0x9E, 0x1B, 0x3C, 0xFF, 0x64, 0x9E, 0x22, 0x44, 0x06, 0x64, 0x9E, 0x29, 0x4C, 0x00, 0x64, 0x9E, 0x30, 0x54, 0xB4, 0x64, 0x9E, 0x37, 0x5C, 0x01, 0x64, 0x9E, 0x3E, 0x64, 0x07, 0x64, 0x9E, 0x45, 0x6C, 0x00, 0x64, 0x9E, 0x4C, 0x74, 0x9E, 0x64, 0x9E, 0x53, 0x7C, 0x02, 0x64, 0x9E, 0x5A, 0x84, 0x07, 0x64, 0x9E, 0x61, 0x8C, 0x00, 0x64, 0x9E, 0x68, 0x94, 0x83, 0x64, 0x9E, 0x6F, 0x9C, 0x04, 0x64, 0x9E, 0x76, 0xA4, 0x07, 0x64, 0x9E, 0x7D, 0xAC, 0x00, 0x64, 0x9E, 0x84, 0xB4, 0x72, 0x64, 0x9E, 0x8B, 0xBC, 0x06, 0x64, 0x9E, 0x92, 0xC4, 0x07, 0x64, 0x9E, 0x99, 0xCC, 0x00, 0x64, 0x9E, 0xA0, 0xD4, 0x57, 0x64, 0x9E, 0xA7, 0xDC, 0x08, 0x64, 0x9E, 0xAE, 0xE4, 0x07, 0x64, 0x9E, 0xB5, 0xEC, 0x14, 0x17, 0x3E]
        totalLength = 0
        mergeLength = 0
        totalBytes = []
        guard bytes.count > 12 else { return }
        let msgId = Int(UInt16(bytes[4]) << 8 | UInt16(bytes[5]))
        switch msgId {
        case 0x8001:
            parseDefaultResponseData(bytes)
        case 0x8002:// 设备信息查询应答
            print("设备信息查询应答")
            let content = parseContentFromBytes(bytes)
            parseDeviceInfoData(content)
        case 0x8009:// 步数、卡路里、距离自动上报
            print("步数、卡路里、距离自动上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8009)
                }
            }else {
                parseStepCalorieDistanceData(content)
            }
        case 0x8010:// 电量变化自动上报
            print("电量变化自动上报")
            Battery = Int(bytes[10])
            for delegate in syncDelegateList {
                delegate.didReceiveBattery(value: Battery)
            }
        case 0x8014:// 电话挂断
            print("电话挂断")
            if bytes[10] == 0x02 {
                for delegate in syncDelegateList {
                    delegate.didReceiveCallOff()
                }
            }
        case 0x8015:// 找手机
            print("找手机")
            let ring = Int(bytes[10])
            for delegate in syncDelegateList {
                delegate.didReceiveFindPhoneCommand(value: ring)
            }
        case 0x8016:// 心率数据上报
            print("心率数据上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8016)
                }
            }else {
                parseHeartRateData(content)
            }
        case 0x8017:// 血氧数据上报
            print("血氧数据上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8017)
                }
            }else {
                parseBlooodOxygenData(content)
            }
        case 0x8018:// 历史体温数据上报
            print("历史体温数据上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8018)
                }
            }else {
                parseTemperaturData(content)
            }
        case 0x8019:// 睡眠数据上报
            print("睡眠数据上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8019)
                }
            }else {
                parseSleepData(content)
            }
        case 0x8020:// 压力数据上报
            print("压力数据上报")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8020)
                }
            }else {
                parsePressureData(content)
            }
//        case 0x8021:// 分时段计步数据上报
//            print("分时段计步数据上报")
//            let content = parseContentFromBytes(bytes)
//            if (content.count == 1 && content.first == 0xff) {
//                for delegate in syncDelegateList {
//                    delegate.didReceiveFinishCommand(0x8021)
//                }
//            }else {
//                parseStepData(content)
//            }
        case 0x8022:// 遥控拍照
            print("遥控拍照")
            let stauts = bytes[10]
            for delegate in syncDelegateList {
                delegate.didReceiveCameraCommand(status: stauts)
            }
        case 0x8023:// 运动实时数据
            print("运动实时数据")
            let content = parseContentFromBytes(bytes)
            if let realtimeData = NewExerciseRealtimeModel.toExerciseRealtimeModel(content) {
                for delegate in syncDelegateList {
                    delegate.didReceiveExerciseRealtimeData(realtimeData: realtimeData)
                }
            }
        case 0x8024:// 运动实时数据
            print("运动实时数据")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8024)
                }
            }else {
                let index = Int(UInt16(bytes[6]) << 8 | UInt16(bytes[7]))
                parseExerciseData(content, index)
            }
        case 0x8025://手表户外运动定位轨迹
            print("gps轨迹")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8025)
                }
            }else {
                parseGpsData(content)
            }
        case 0x8027://运动状态
            print("运动状态")
            let status = Int(bytes[10])
            for delegate in syncDelegateList {
                delegate.didReceiveExerciseStatus(value: status)
            }
        case 0x8028://中高强度时长
            print("中高强度时长")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8028)
                }
            }else {
                parseIntensiveTimeData(content)
            }
        case 0x8029://北斗卡号
            print("北斗卡号")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8029)
                }
            }else {
                parseBeidouCardData(content)
            }
        case 0x8030://勿扰模式
            print("勿扰模式")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8030)
                }
            }else {
                parseNoDisturbData(content)
            }
        case 0x8031://血氧自动测量开关
            print("血氧自动测量开关")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8031)
                }
            }else {
                parseBoAutoDetectData(content)
            }
        case 0x8032://血氧预警开关
            print("血氧自动测量开关")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8032)
                }
            }else {
                parseBoLowRemindData(content)
            }
        case 0x8033://心率自动测量开关
            print("心率自动测量开关")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8033)
                }
            }else {
                parseHrAutoDetectData(content)
            }
        case 0x8035://运动心率预警开关
            print("运动心率预警开关")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8035)
                }
            }else {
                parseExerciseHrRemindData(content)
            }
        case 0x8037://固件版本号
            print("固件版本号")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8037)
                }
            }else {
                parseFirmwareVersionData(content)
            }
        case 0x8038://抬腕提醒开关
            print("抬腕提醒开关")
            let content = parseContentFromBytes(bytes)
            if (content.count == 1 && content.first == 0xff) {
                for delegate in syncDelegateList {
                    delegate.didReceiveFinishCommand(0x8038)
                }
            }else {
                parseWristSenseData(content)
            }
        default:
            break
        }
//        switch cmd {
//        case .set, .find, .device, .remind, .firmware:
//            parseSetData(SetCmd(rawValue: bytes[10]), data: data)
//        case .sync:
//            let valueBytes = Array(bytes[13..<bytes.count])
//            print(valueBytes)
//            parseSyncData(SyncCmd(rawValue: bytes[10]), bytes: valueBytes)
//        case .weather:
//            if setCmdClosure != nil {
//                setCmdClosure?(nil)
//                setCmdClosure = nil
//            }
//        }
    }
    
    private func parseContentFromBytes(_ bytes: [UInt8]) -> [UInt8] {
        let contentLength = Int(bytes[9]) // 获取内容长度
        guard bytes.count >= 10 + contentLength else {
            return [] // 如果字节数组长度不足以包含内容，返回空数组
        }
        let content = Array(bytes[10..<(10 + contentLength)]) // 获取内容部分
        return content
    }
    
    // 通用返回数据
    private func parseDefaultResponseData(_ bytes: [UInt8]) {
        guard bytes.count == 17, bytes[9] == 5 else {
            return
        }
        let newcmd = NewCmd(rawValue: bytes[13])
//        switch newcmd {
//        case .setTime, .setTimeFormat, .setTemperatureUnit, .setDistanceUnit, .setWristSense, .setTouchSense, .setLowPowerRemind, .setLanguage, .setHeartRateDetectInterval, .setPressureAutoDetect, .setBloodOxygenAutoDetect, .setUserInfo, .setNoDisturb, .setWeather, .setBeiDouContact, .setBeiDouQuickAnswer, .setRestHeartRateRemind, .setExerciseHeartRateRemind, .setBloodOxygenLowRemind, .setMessageRemind, .setFindWatch:
            if setCmdClosure != nil {
                let success = bytes[14] == 0
                if success {
                    setCmdClosure?(nil)
                }else {
                    setCmdClosure?((Int)(bytes[14]))
                }
                setCmdClosure = nil
            }
//        case .none:
//            break
//        default:
//            break
//        }
    }
    
    // 设备信息数据
    private func parseDeviceInfoData (_ content:[UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            return
        }
        let totalInfoCount = Int(content[0])
        var currentIndex = 1
        
        // 检查总信息数是否大于0
        guard totalInfoCount > 0 else {
            print("无有效的信息")
            return
        }
        for _ in 0..<totalInfoCount {
            // 检查是否有足够的字节用于解析信息
            guard currentIndex + 2 < content.count else {
                print("数据不完整")
                return
            }
            let infoID = Int(content[currentIndex])
            currentIndex += 1
            let infoLength = Int(content[currentIndex])
            currentIndex += 1
            // 检查内容长度是否与实际字节匹配
            guard currentIndex + infoLength <= content.count else {
                print("信息内容长度不匹配")
                return
            }
            let info = content[currentIndex..<(currentIndex + infoLength)]
            currentIndex += infoLength
            
            // 在此处执行对每个info的操作
            print("ID: \(infoID)")
            print("内容: \(info)")
        }
    }
    
    // 心跳数据
    func parseHeartRateData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            heartRateClosure?([], nil)
            return
        }
        let hrArray = HeartRateModel.toHeartRateArray(content)
        HeartRateModel.addArray(hrArray)// 加入数据库
        guard hrArray.count > 0 else {
            return
        }
        heartRateClosure?(hrArray, nil)
    }
    
    // 血氧数据
    func parseBlooodOxygenData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            bloodOxygenClosure?([], nil)
            return
        }
        let array = BloodOxygenModel.toBloodOxygenArray(content)
        guard array.count > 0 else {
            return
        }
        BloodOxygenModel.addArray(array)// 加入数据库
        bloodOxygenClosure?(array, nil)
    }
    
    // 体温数据
    func parseTemperaturData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            return
        }
        let array = TemperatureModel.toTemperatureArray(content)
        TemperatureModel.addArray(array)// 加入数据库
    }
    
    // 压力数据
    func parsePressureData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            pressureClosure?([], nil)
            return
        }
        let array = PressureModel.toPressureArray(content)
        guard array.count > 0 else {
            return
        }
        PressureModel.addArray(array)// 加入数据库
        pressureClosure?(array, nil)
    }
    
    // 计步数据
    // not used now
    func parseStepData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            stepClosure?([], nil)
            return
        }
        let array = StepModel.toStepArray(content)
        StepModel.addArray(array)// 加入数据库
//        stepClosure?(array, nil)
    }
    
    // 睡眠数据
    func parseSleepData (_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            sleepClosure?(nil, nil)
            return
        }
        let model = NewSleepModel.toSleepModel(content)
        sleepClosure?(model, nil)
    }
    
    // 步数，卡路里，距离数据
    func parseStepCalorieDistanceData (_ content: [UInt8]) {
        guard content.count >= 16 else {
            print("无有效的信息")
//            stepClosure?([], nil)
            return
        }
        let steps = NewStepModel.toStepArray(content)
//        step.realTimeAdd()// 加入数据库
        for delegate in syncDelegateList {
            delegate.didReceiveStep()
        }
        stepClosure?(steps, nil)
    }
    
    // GPS数据
    func parseGpsData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            gpsClosure?(nil, nil)
            return
        }
        let gpsModel = NewGpsModel.toGpsModel(content)
        gpsClosure?(gpsModel, nil)
    }
    
    // 中高强度时长数据
    func parseIntensiveTimeData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
//            intensiveTimeClosure?(nil, nil)
            return
        }
        let gpsModel = NewIntensiveTimeModel.toIntensiveTimeModel(content)
        intensiveTimeClosure?(gpsModel, nil)
    }
    
    // 北斗卡号数据
    func parseBeidouCardData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            beidouCardClosure?(nil, nil)
            return
        }
        let card = String(bytes: content, encoding: .ascii)
        beidouCardClosure?(card, nil)
    }
    
    // 勿扰模式
    func parseNoDisturbData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            noDisturbClosure?(nil, nil)
            return
        }
        let noDisturb = NewNoDisturbModel.toNoDisturbModel(content)
        noDisturbClosure?(noDisturb, nil)
    }
    
    // 血氧自动测量开关
    func parseBoAutoDetectData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            boAutoDetectClosure?(false, nil)
            return
        }
        let enable = (content[0] == 0x01)
        boAutoDetectClosure?(enable, nil)
    }
    
    // 血氧预警开关
    func parseBoLowRemindData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            boLowRemindClosure?(0, nil)
            return
        }
        let value = Int(content[0])
        boLowRemindClosure?(value, nil)
    }
    
    // 心率自动测量开关
    func parseHrAutoDetectData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            hrAutoDetectClosure?(false, nil)
            return
        }
        let enable = (content[0] == 0x01)
        hrAutoDetectClosure?(enable, nil)
    }
    
    // 运动心率预警开关
    func parseExerciseHrRemindData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            exerciseHrRemindClosure?(false, nil)
            return
        }
        let enable = (content[0] == 0x01)
        exerciseHrRemindClosure?(enable, nil)
    }
    
    // 运动数据
    func parseExerciseData(_ content: [UInt8], _ index: Int) {
        guard content.count > 0 else {
            print("无有效的信息")
//            exerciseClosure?(nil, nil)
            return
        }
        NewExerciseModel.toExerciseModel(content, index)
        if let em = localExerciseModel, index == 7 {
            for delegate in syncDelegateList {
                delegate.didReceiveExerciseData(exerciseData: em)
            }
            exerciseClosure?(em, nil)
        }

    }
    
    // 固件版本号数据
    func parseFirmwareVersionData(_ content: [UInt8]) {
        guard content.count > 1 else {
            print("无有效的信息")
            firmwareVersionClosure?(nil, nil, nil)
            return
        }
        firmwareVersionClosure?(Int(content[0]), Int(content[1]), nil)
    }
    
    // 抬腕提醒开关
    func parseWristSenseData(_ content: [UInt8]) {
        guard content.count > 0 else {
            print("无有效的信息")
            wristSenseClosure?(false, nil)
            return
        }
        let enable = (content[0] == 0x01)
        wristSenseClosure?(enable, nil)
    }
}