//
//  BlufiClient.m
//  EspBlufi
//
//  Created by AE on 2020/6/9.
//  Copyright © 2020 espressif. All rights reserved.
//

#import "BlufiClient.h"
#import "BlufiNotifyData.h"
#import "BlufiFrameCtrlData.h"
#import "BlufiSecurity.h"
#import "BlufiConfigureParams.h"

#define PACKAGE_LENGTH_DEFAULT   128
#define PACKAGE_LENGTH_MIN       20
#define PACKAGE_HEADER_LENGTH    4

#define DBUG false

typedef enum {
    StateConnected = 0,
    StateDisconnected,
} ConnectionState;

typedef enum {
    NotifyComplete = 0,
    NotifyHasFrag,
    NotifyNull,
    NotifyInvalidLength,
    NotifyInvalidSequence,
    NotifyInvalidChecsum,
    NotifyError,
} NotifyStatus;

enum {
    NegSecuritySetTotalLength = 0,
    NegSecuritySetAllData,
};

@interface EspBlockingQueue : NSObject

- (void)enqueue:(id)object;

- (id)dequeue;

- (void)cancel;

@end

@interface BlufiClient() <CBCentralManagerDelegate, CBPeripheralDelegate>

@property(strong, nonatomic, readonly)CBPeripheral *peripheral;

@property(strong, nonatomic)NSOperationQueue *requestQueue;
@property(strong, nonatomic)NSOperationQueue *callbackQueue;

@property(strong, nonatomic)NSUUID *identifier;

@property(strong, nonatomic)CBCentralManager *centralManager;
@property(strong, nonatomic)CBService *service;
@property(strong, nonatomic)CBUUID const *writeUUID;
@property(strong, nonatomic)CBCharacteristic *writeChar;
@property(strong, nonatomic)NSCondition *writeCondition;
@property(strong, nonatomic)CBUUID const *notifyUUID;
@property(strong, nonatomic)CBCharacteristic *notifyChar;

@property(assign, atomic)BOOL blePowerOn;
@property(assign, atomic)BOOL bleConnectMark;

@property(assign, atomic)NSInteger sendSequence;
@property(assign, atomic)NSInteger readSequence;

@property(strong, nonatomic)BlufiNotifyData *notifyData;

@property(strong, nonatomic)NSData *aesKey;

@property(assign, nonatomic)BOOL encrypted;
@property(assign, nonatomic)BOOL checksum;
@property(assign, nonatomic)BOOL requireAck;

@property(strong, nonatomic)EspBlockingQueue *deviceAck;
@property(strong, nonatomic)EspBlockingQueue *deviceKey;

@property(assign, nonatomic)ConnectionState connectState;

@property(assign, nonatomic)BOOL closed;

@end

@implementation BlufiClient

- (instancetype)init {
    self = [super init];
    if (self) {
        _centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];
        _writeUUID = [CBUUID UUIDWithString:UUID_WRITE_CHAR];
        _writeCondition = [[NSCondition alloc] init];
        _notifyUUID = [CBUUID UUIDWithString:UUID_NOTIFY_CHAR];
        _callbackQueue = [NSOperationQueue mainQueue];
        _requestQueue = [[NSOperationQueue alloc] init];
        _requestQueue.maxConcurrentOperationCount = 1;
        
        _bleConnectMark = NO;
        _blePowerOn = NO;
        
        _postPackageLengthLimit = PACKAGE_LENGTH_DEFAULT;
        
        _sendSequence = -1;
        _readSequence = -1;
        
        _encrypted = NO;
        _checksum = NO;
        _requireAck = NO;
        
        _deviceAck = [[EspBlockingQueue alloc] init];
        _deviceKey = [[EspBlockingQueue alloc] init];
        
        _closed = NO;
    }
    return self;
}

- (NSString *)hexFromUint4:(Byte)b {
    switch (b) {
        case 0: return @"0";
        case 1: return @"1";
        case 2: return @"2";
        case 3: return @"3";
        case 4: return @"4";
        case 5: return @"5";
        case 6: return @"6";
        case 7: return @"7";
        case 8: return @"8";
        case 9: return @"9";
        case 10: return @"A";
        case 11: return @"B";
        case 12: return @"C";
        case 13: return @"D";
        case 14: return @"E";
        case 15: return @"F";
    }
    return nil;
}

- (NSString *)hexFromBytes:(Byte *)bytes length:(NSInteger)length{
    NSMutableString *hex = [[NSMutableString alloc] init];
    for (NSInteger i = 0; i < length; ++i) {
        Byte b = bytes[i];
        [hex appendString:[self hexFromUint4:(b >> 4 & 0xf)]];
        [hex appendString:[self hexFromUint4:(b & 0xf)]];
    }
    return hex;
}

- (void)setPostPackageLengthLimit:(NSInteger)postPackageLengthLimit {
    if (postPackageLengthLimit <= PACKAGE_LENGTH_MIN) {
        _postPackageLengthLimit = PACKAGE_LENGTH_MIN;
    } else {
        _postPackageLengthLimit = postPackageLengthLimit;
    }
}

- (void)close {
    _closed = YES;
    [_callbackQueue cancelAllOperations];
    [_requestQueue cancelAllOperations];
    [_centralManager stopScan];
    [self clearConnection];
    
    _blufiDelegate = nil;
    _centralManagerDelete = nil;
    _peripheralDelegate = nil;
    _centralManager.delegate = nil;
    
    [_deviceAck cancel];
    [_deviceKey cancel];
}

- (void)scanBLE {
    NSLog(@"Blufi Scan device: %@", _identifier);
    [_centralManager scanForPeripheralsWithServices:nil options:nil];
}

- (void)connect:(NSString *)identifier {
    if (_closed) {
        @throw [[NSException alloc] initWithName:@"NSStateException" reason:@"The BlufiClient is closed" userInfo:nil];
        return;
    }
    [self clearConnection];
    _identifier = [[NSUUID alloc] initWithUUIDString:identifier];
    if (_blePowerOn) {
        [self scanBLE];
    } else {
        _bleConnectMark = YES;
    }
}

- (void)clearConnection {
    _bleConnectMark = NO;
    _connectState = StateDisconnected;
    if (_peripheral) {
        [_centralManager cancelPeripheralConnection:_peripheral];
        _peripheral = nil;
    }
    _service = nil;
    _writeChar = nil;
    _notifyChar = nil;
    [_deviceAck cancel];
}

- (Byte)getTypeValueWithPackageType:(PackageType)pkgType subType:(SubType)subType {
    return (subType << 2) | pkgType;
}

- (PackageType)getPackageTypeWithTypeValue:(NSInteger)typeValue {
    return typeValue & 0b11;
}

- (SubType)getSubTypeWithTypeValue:(NSInteger)typeValue {
    return ((typeValue & 0b11111100) >> 2);
}

- (Byte)generateSendSequence {
    return (++_sendSequence) & 0xff;
}

- (NSData *)generateAESIV:(Byte)sequence {
    Byte buf[16];
    memset(buf, 0, 16);
    buf[0] = sequence;
    return [NSData dataWithBytes:buf length:16];
}

- (BOOL)isConnected {
    return _connectState == StateConnected;
}

- (void)gattWrite:(NSData *)data {
    [_writeCondition lock];
    if (![self isConnected]) {
        [_writeCondition unlock];
        return;
    }
    if (DBUG) {
        NSLog(@"Blufi GattWrite Length: %lu,  %@", (unsigned long)data.length, data);
    }
    [_peripheral writeValue:data forCharacteristic:_writeChar type:CBCharacteristicWriteWithResponse];
    [_writeCondition wait];
    [_writeCondition unlock];
    return;
}

- (BOOL)receiveAck:(Byte)expectAck {
    NSLog(@"receiveAck expect: %d", expectAck);
    NSNumber *number = [_deviceAck dequeue];
    if (!number) {
        NSLog(@"receiveAck nil");
        return NO;
    }
    Byte ack = number.intValue;
    NSLog(@"receiveAck: %d", ack);
    return ack == expectAck;
}

- (BOOL)post:(NSData *)data encrypt:(BOOL)encrypt checksum:(BOOL)checksum requireAck:(BOOL)ack type:(Byte)type {
    if (data && data.length > 0) {
        return [self postContainData:data encrypt:encrypt checksum:checksum requireAck:ack type:type];
    } else {
        return [self postEmptyDataWithEncrypt:encrypt checksum:checksum requireAck:ack type:type];
    }
    
    return NO;
}

- (BOOL)postEmptyDataWithEncrypt:(BOOL)encrypt checksum:(BOOL)checksum requireAck:(BOOL)ack type:(Byte)type {
    Byte sequence = [self generateSendSequence];
    NSData *postPacket = [self getPostPacket:nil type:type encrypt:encrypt checksum:checksum requireAck:ack hasFrag:NO sequence:sequence];
    [self gattWrite:postPacket];
    
    return !ack || [self receiveAck:sequence];
}

- (BOOL)postContainData:(NSData *)data encrypt:(BOOL)encrypt checksum:(BOOL)checksum requireAck:(BOOL)ack type:(Byte)type {
    NSInputStream *dataIS = [NSInputStream inputStreamWithData:data];
    NSInteger dataLengthLimit = _postPackageLengthLimit - PACKAGE_HEADER_LENGTH;
    dataLengthLimit -= 2; // If frag, two bytes total length in data
    if (checksum) {
        dataLengthLimit -= 2;
    }
    
    Byte dataBuf[dataLengthLimit];
    NSInteger available = data.length;
    [dataIS open];
    while (dataIS.hasBytesAvailable) {
        NSInteger read = [dataIS read:dataBuf maxLength:dataLengthLimit];
        if (read == 0) {
            break;
        }
        
        NSMutableData *dataContent = [[NSMutableData alloc] init];
        available -= read;
        [dataContent appendBytes:dataBuf length:read];
        if (available > 0 && available <= 2) {
            Byte last[available];
            read = [dataIS read:last maxLength:available];
            if (read != available) {
                // Impossiable come here
                NSLog(@"postContainData: read last bytes error: read=%ld, expect=%ld", (long)read, (long)available);
            }
            [dataContent appendBytes:last length:available];
            available -= read;
        }
        BOOL frag = dataIS.hasBytesAvailable;
        if (frag) {
            NSInteger totalLen = dataContent.length + available;
            NSMutableData *newDataContent = [[NSMutableData alloc] init];
            Byte totalLenBytes[] = {totalLen & 0xff, totalLen >> 8 & 0xff};
            [newDataContent appendBytes:totalLenBytes length:2];
            [newDataContent appendData:dataContent];
            dataContent = newDataContent;
        }
        Byte sequence = [self generateSendSequence];
        NSData *postPacket = [self getPostPacket:dataContent type:type encrypt:encrypt checksum:checksum requireAck:ack hasFrag:frag sequence:sequence];
        
        [self gattWrite:postPacket];
        if (frag) {
            if (ack && ![self receiveAck:sequence]) {
                [dataIS close];
                return NO;
            }
            [NSThread sleepForTimeInterval:0.01];
        } else {
            [dataIS close];
            return !ack || [self receiveAck:sequence];
        }
    }
    [dataIS close];
    return YES;
}

- (NSData *)getPostPacket:(NSData *)data type:(Byte)type encrypt:(BOOL)encrypt checksum:(BOOL)checksum requireAck:(BOOL)ack hasFrag:(BOOL)hasFrag sequence:(Byte)sequence {
    NSMutableData *result = [[NSMutableData alloc] init];
    
    Byte dataLength = data ? data.length : 0;
    Byte frameCtrl = [BlufiFrameCtrlData getFrameCtrlValueWithEncrypted:encrypt checksum:checksum direction:DataOutput requireAck:ack hasFrag:hasFrag];
    
    Byte header[] = {type, frameCtrl, sequence, dataLength};
    [result appendBytes:header length:4];
    
    NSData *checksumData = nil;
    if (checksum) {
        Byte buf[] = {sequence, dataLength};
        NSInteger crc = [BlufiSecurity crc:0 buf:buf length:2];
        if (dataLength > 0) {
            crc = [BlufiSecurity crc:crc data:data];
        }
        
        buf[0] = crc & 0xff;
        buf[1] = crc >> 8 & 0xff;
        checksumData = [NSData dataWithBytes:buf length:2];
    }
    
    if (encrypt && data && data.length > 0) {
        NSData *iv = [self generateAESIV:sequence];
        data = [BlufiSecurity aesEncrypt:data key:_aesKey iv:iv];
    }
    if (data && data.length > 0) {
        [result appendData:data];
    }
    if (checksumData) {
        [result appendData:checksumData];
    }
    
    return result;
}

- (NotifyStatus)parseNotification:(NSData *)response notification:(BlufiNotifyData *)notification {
    if (!response) {
        NSLog(@"parseNotification nil response");
        return NotifyNull;
    }
    if (DBUG) {
        NSLog(@"Notification: %@", response);
    }
    
    if (response.length < 4) {
        NSLog(@"parseNotification invalid length");
        return NotifyInvalidLength;
    }
    
    Byte *buf = (Byte *)response.bytes;
    Byte sequence = buf[2];
    Byte expectSequence = (++_readSequence) & 0xff;
    if (sequence != expectSequence) {
        NSLog(@"parseNotification invalid sequence");
        return NotifyInvalidSequence;
    }
    
    Byte type = buf[0];
    PackageType pkgType = [self getPackageTypeWithTypeValue:type];
    SubType subType = [self getSubTypeWithTypeValue:type];
    notification.typeValue = type;
    notification.packageType = pkgType;
    notification.subType = subType;
    
    Byte frameCtrl = buf[1];
    notification.frameCtrl = frameCtrl;
    BlufiFrameCtrlData *frameCtrlData = [[BlufiFrameCtrlData alloc] initWithValue:frameCtrl];
    
    Byte dataLen = buf[3];
    Byte dataBuf[dataLen];
    Byte dataOffset = 4;
    if (dataLen + dataOffset > response.length) {
        NSLog(@"parseNotification invalid data length");
        return NotifyError;
    }
    memcpy(dataBuf, buf + dataOffset, dataLen);
    NSData *data = [NSData dataWithBytes:dataBuf length:dataLen];
    
    if (frameCtrlData.isEncrypted) {
        NSData *iv =[self generateAESIV:sequence];
        data = [BlufiSecurity aesDecrypt:data key:_aesKey iv:iv];
        memcpy(dataBuf, data.bytes, data.length);
    }
    
    if (frameCtrlData.isChecksum) {
        Byte respChecksum1 = buf[response.length - 1];
        Byte respChecksum2 = buf[response.length - 2];
        
        Byte checkBuf[] = {sequence, dataLen};
        NSInteger crc = [BlufiSecurity crc:0 buf:checkBuf length:2];
        crc = [BlufiSecurity crc:crc data:data];
        Byte calcChecksum1 = crc >> 8 & 0xff;
        Byte calcChecksum2 = crc & 0xff;
        
        if (respChecksum1 != calcChecksum1 || respChecksum2 != calcChecksum2) {
            NSLog(@"parseNotification invalid checksum");
            return NotifyInvalidChecsum;
        }
    }
    
    NSData *appendData;
    if (frameCtrlData.hasFrag) {
        Byte dataSegment[dataLen - 2];
        memcpy(dataSegment, dataBuf + 2, dataLen - 2);
        appendData = [NSData dataWithBytes:dataSegment length:dataLen - 2];
    } else {
        appendData = [NSData dataWithBytes:dataBuf length:dataLen];
    }
    
    [notification appendData:appendData];
    
    return frameCtrlData.hasFrag ? NotifyHasFrag : NotifyComplete;
}

- (void)parseBlufiNotifyData:(BlufiNotifyData *)data {
    PackageType pkgType = data.packageType;
    SubType subType = data.subType;
    NSData *dataContent = data.getData;
    
    if (_blufiDelegate && [_blufiDelegate respondsToSelector:@selector(blufi:gattNotification:packageType:subType:)]) {
        BOOL complete = [_blufiDelegate blufi:self gattNotification:dataContent packageType:pkgType subType:subType];
        if (complete) {
            return;
        }
    }
    
    switch (pkgType) {
        case PackageCtrl:
            [self parseCtrlData:dataContent subType:subType];
            break;
        case PackageData:
            [self parseDataData:dataContent subType:subType];
            break;
    }
}

- (void)parseCtrlData:(NSData *)data subType:(SubType)subType {
    if (subType == CtrlSubTypeAck) {
        [self parseAck:data];
    }
}

- (void)parseDataData:(NSData *)data subType:(SubType)subType {
    switch (subType) {
        case DataSubTypeNeg:
            if (!_closed) {
                [_deviceKey enqueue:data];
            }
            break;
        case DataSubTypeVersion:
            [self parseVersion:data];
            break;
        case DataSubTypeWiFiConnectionState:
            [self parseWifiState:data];
            break;
        case DataSubTypeWiFiList:
            [self parseWiFiScanList:data];
            break;
        case DataSubTypeCustomData:
            [self onReceiveCustomData:data status:StatusSuccess];
            break;
        case DataSubTypeError: {
            NSInteger errCode = data.length > 0 ? ((Byte *)data.bytes)[0] : 300;
            [self onError:errCode];
        }
            break;
    }
}

- (void)parseAck:(NSData *)data {
    int ack = 0x100;
    if (data.length > 0) {
        ack = ((Byte *)data.bytes)[0];
    }
    [_deviceAck enqueue:[NSNumber numberWithInt:ack]];
}

- (void)onVersionResponse:(BlufiVersionResponse *)response status:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didReceiveDeviceVersionResponse:status:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didReceiveDeviceVersionResponse:response status:code];
        }];
    }
}

- (void)parseVersion:(NSData *)data {
    BlufiStatusCode code;
    BlufiVersionResponse *response;
    Byte *buf = (Byte *)data.bytes;
    if (data.length != 2) {
        code = StatusInvalidData;
        response = nil;
    } else {
        code = StatusSuccess;
        response = [[BlufiVersionResponse alloc] init];
        response.bigVer = buf[0];
        response.smallVer = buf[1];
    }
    
    [self onVersionResponse:response status:code];
}

- (void)onDeviceStatusResponse:(BlufiStatusResponse *)response status:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didReceiveDeviceStatusResponse:status:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didReceiveDeviceStatusResponse:response status:code];
        }];
    }
}

- (void)parseWifiState:(NSData *)data {
    BlufiStatusCode code;
    BlufiStatusResponse *response;
    if (data.length < 3) {
        code = StatusInvalidData;
        response = nil;
    } else {
        code = StatusSuccess;
        response = [[BlufiStatusResponse alloc] init];
        
        Byte temp[data.length];
        NSInputStream *dataIS = [NSInputStream inputStreamWithData:data];
        [dataIS open];
        
        [dataIS read:temp maxLength:1];
        response.opMode = temp[0];
        
        [dataIS read:temp maxLength:1];
        response.staConnectionStatus = temp[0];
        
        [dataIS read:temp maxLength:1];
        response.softApConnectionCount = temp[0];
        
        while (dataIS.hasBytesAvailable) {
            NSInteger read = [dataIS read:temp maxLength:2];
            if (read != 2) {
                NSLog(@"parseWifiState contain invalid data1");
                code = StatusInvalidData;
                break;
            }
            Byte infoType = temp[0];
            Byte len = temp[1];
            read = [dataIS read:temp maxLength:len];
            if (read != len) {
                NSLog(@"parseWifiState contain invalid data2");
                code = StatusInvalidData;
                break;
            }
            [self parseWifiStateData:temp length:len type:infoType response:response];
        }
        
        [dataIS close];
    }
    
    [self onDeviceStatusResponse:response status:code];
}

- (void)parseWifiStateData:(Byte *)data length:(NSInteger)length type:(Byte)infoType response:(BlufiStatusResponse *)response {
    switch (infoType) {
        case DataSubTypeStaBssid: {
            NSString *bssid = [self hexFromBytes:data length:length];
            response.staBssid = bssid;
        }
            break;
        case DataSubTypeStaSsid: {
            NSString *ssid = [[NSString alloc] initWithBytes:data length:length encoding:NSUTF8StringEncoding];
            response.staSsid = ssid;
        }
            break;
        case DataSubTypeStaPassword: {
            NSString *password = [[NSString alloc] initWithBytes:data length:length encoding:NSUTF8StringEncoding];
            response.staPassword = password;
        }
            break;
        case DataSubTypeSoftAPAuthMode:
            response.softApSecurity = data[0];
            break;
        case DataSubTypeSoftAPChannel:
            response.softApChannel = data[0];
            break;
        case DataSubTypeSoftAPMaxConnection:
            response.softApMaxConnection = data[0];
            break;
        case DataSubTypeSoftAPPassword: {
            NSString *password = [[NSString alloc] initWithBytes:data length:length encoding:NSUTF8StringEncoding];
            response.softApPassword = password;
        }
            break;
        case DataSubTypeSoftAPSsid: {
            NSString *ssid = [[NSString alloc] initWithBytes:data length:length encoding:NSUTF8StringEncoding];
            response.softApSsid = ssid;
        }
            break;
    }
}
//--自定义
- (void)blufi:(BlufiClient *)client didReceiveDeviceScanResponse:(NSArray<BlufiScanResponse *> *)scanResults status:(BlufiStatusCode)status {
    if (status == StatusSuccess) {
        NSLog(@"xcode接收到蓝牙应答");
    } else {
    }
}

- (void)onDeviceScanList:(NSMutableArray<BlufiScanResponse *> *)list status:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didReceiveDeviceScanResponse:status:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didReceiveDeviceScanResponse:list status:StatusSuccess];
        }];
    }
}

- (void)parseWiFiScanList:(NSData *)data {
    NSMutableArray<BlufiScanResponse *> *result = [NSMutableArray array];
    
    NSInputStream *dataIS = [NSInputStream inputStreamWithData:data];
    Byte temp[data.length];
    [dataIS open];
    while (dataIS.hasBytesAvailable) {
        NSInteger read = [dataIS read:temp maxLength:2];
        if (read != 2) {
            NSLog(@"parseWiFiScanList contain invalid data1");
            break;
        }
        Byte length = temp[0];
        if (length < 1) {
            NSLog(@"parseWiFiScanList invalid length");
            break;
        }
        Byte rssi = temp[1];
        read = [dataIS read:temp maxLength:length - 1];
        if (read != length - 1) {
            NSLog(@"parseWiFiScanList invalid ssid data");
            break;
        }
        NSString *ssid = [[NSString alloc] initWithBytes:temp length:length - 1 encoding:NSUTF8StringEncoding];
        
        BlufiScanResponse *response = [[BlufiScanResponse alloc] init];
        response.type = 0x01;
        response.rssi = rssi;
        response.ssid = ssid;
        [result addObject:response];
    }
    [dataIS close];
    
    [self onDeviceScanList:result status:StatusSuccess];
}

- (void)onError:(NSInteger)errCode {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didReceiveError:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didReceiveError:errCode];
        }];
    }
}

- (void)onPostCustomData:(NSData *)data status:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didPostCustomData:status:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didPostCustomData:data status:code];
        }];
    }
}

- (void)onReceiveCustomData:(NSData *)data status:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didReceiveCustomData:status:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didReceiveCustomData:data status:code];
        }];
    }
}

- (void)requestCloseConnection {
    [_requestQueue addOperationWithBlock:^{
        Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeCloseConnection];
        [self post:nil encrypt:NO checksum:NO requireAck:NO type:type];
    }];
}

- (void)requestDeviceVersion {
    BOOL encrypted = _encrypted;
    BOOL checksum = _checksum;
    [_requestQueue addOperationWithBlock:^{
        Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeGetVersion];
        BOOL posted = [self post:nil encrypt:encrypted checksum:checksum requireAck:false type:type];
        if (!posted) {
            NSLog(@"Post DeiviceVersion request failed");
            [self onVersionResponse:nil status:StatusWriteFailed];
        }
    }];
}

- (void)requestDeviceStatus {
    BOOL encrypted = _encrypted;
    BOOL checksum = _checksum;
    [_requestQueue addOperationWithBlock:^{
        Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeGetWiFiStatus];
        BOOL posted = [self post:nil encrypt:encrypted checksum:checksum requireAck:false type:type];
        if (!posted) {
            NSLog(@"Post DeviceStatus request failed");
            [self onDeviceStatusResponse:nil status:StatusWriteFailed];
        }
    }];
}

- (void)requestDeviceScan {
    NSLog(@"Post WiFiScan request -1");
    BOOL encrypted = _encrypted;
    BOOL checksum = _checksum;
    [_requestQueue addOperationWithBlock:^{
        NSLog(@"Post WiFiScan request 0");
        Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeGetWiFiList];
        BOOL posted = [self post:nil encrypt:encrypted checksum:checksum requireAck:false type:type];
        if (!posted) {
            NSLog(@"Post WiFiScan request failed");
            [self onDeviceScanList:nil status:StatusWriteFailed];
        }else{
            NSLog(@"Post WiFiScan request success");
        }
    }];
}

- (void)postCustomData:(NSData *)data {
    BOOL encrypted = _encrypted;
    BOOL checksum = _checksum;
    BOOL ack = _requireAck;
    [_requestQueue addOperationWithBlock:^{
        Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeCustomData];
        BOOL posted = [self post:data encrypt:encrypted checksum:checksum requireAck:ack type:type];
        BlufiStatusCode code = posted ? StatusSuccess : StatusWriteFailed;
        [self onPostCustomData:data status:code];
    }];
}

- (void)onPostConfigureParams:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didPostConfigureParams:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didPostConfigureParams:code];
        }];
    }
}

- (BOOL)postDeviceMode:(OpMode)opMode {
    Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeSetOpMode];
    Byte buf[] = {opMode};
    NSData *data = [NSData dataWithBytes:buf length:1];
    return [self post:data encrypt:_encrypted checksum:_checksum requireAck:YES type:type];
}

- (BOOL)postStaInfo:(BlufiConfigureParams *)params {
    Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeStaSsid];
    NSData *ssid = [params.staSsid dataUsingEncoding:NSUTF8StringEncoding];
    if (![self post:ssid encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
        return NO;
    }
    [NSThread sleepForTimeInterval:0.01];
    
    type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeStaPassword];
    NSData *password = [params.staPassword dataUsingEncoding:NSUTF8StringEncoding];
    if (![self post:password encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
        return NO;
    }
    [NSThread sleepForTimeInterval:0.01];
    
    type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeConnectWiFi];
    return [self post:nil encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type];
}

- (BOOL)postSoftAPInfo:(BlufiConfigureParams *)params {
    NSData *ssid = params.softApSsid ? [params.softApSsid dataUsingEncoding:NSUTF8StringEncoding] : nil;
    if (ssid && ssid.length > 0) {
        Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeSoftAPSsid];
        if (![self post:ssid encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
            return NO;
        }
        [NSThread sleepForTimeInterval:0.01];
    }
    
    NSData *password = params.softApPassword ? [params.softApPassword dataUsingEncoding:NSUTF8StringEncoding] : nil;
    if (password && password.length > 0) {
        Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeSoftAPPassword];
        if (![self post:password encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
            return NO;
        }
        [NSThread sleepForTimeInterval:0.01];
    }
    
    NSInteger channel = params.softApChannel;
    if (channel > 0) {
        Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeSoftAPChannel];
        Byte buf[] = {channel};
        NSData *data = [NSData dataWithBytes:buf length:1];
        if (![self post:data encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
            return NO;
        }
        [NSThread sleepForTimeInterval:0.01];
    }
    
    NSInteger maxConn = params.softApMaxConnection;
    if (maxConn > 0) {
        Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeSoftAPMaxConnection];
        Byte buf[] = {maxConn};
        NSData *data = [NSData dataWithBytes:buf length:1];
        if (![self post:data encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type]) {
            return NO;
        }
        [NSThread sleepForTimeInterval:0.01];
    }
    
    Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeSoftAPAuthMode];
    Byte buf[] = {(Byte)params.softApSecurity};
    NSData *data = [NSData dataWithBytes:buf length:1];
    return [self post:data encrypt:_encrypted checksum:_checksum requireAck:_requireAck type:type];
}

- (void)configure:(BlufiConfigureParams *)params {
    [_requestQueue addOperationWithBlock:^{
        OpMode opMode  = params.opMode;
        switch (opMode) {
            case OpModeNull:
                if (![self postDeviceMode:opMode]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                [self onPostConfigureParams:StatusSuccess];
                break;
            case OpModeSta:
                if (![self postDeviceMode:opMode]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                if (![self postStaInfo:params]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                [self onPostConfigureParams:StatusSuccess];
                break;
            case OpModeSoftAP:
                if (![self postDeviceMode:opMode]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                if (![self postSoftAPInfo:params]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                [self onPostConfigureParams:StatusSuccess];
                break;
            case OpModeStaSoftAP:
                if (![self postDeviceMode:opMode]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                if (![self postStaInfo:params]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                if (![self postSoftAPInfo:params]) {
                    [self onPostConfigureParams:StatusWriteFailed];
                    return;
                }
                [self onPostConfigureParams:StatusSuccess];
                break;
            default:
                NSLog(@"configure invalid OpMode: %d", opMode);
                [self onPostConfigureParams:StatusInvalidRequest];
                break;
        }
    }];
}

- (BlufiDH *)postNegotiateSecurity {
    Byte type = [self getTypeValueWithPackageType:PackageData subType:DataSubTypeNeg];
    BlufiDH *blufiDH = [BlufiSecurity dhGenerateKeys];
    NSData *p = blufiDH.p;
    NSData *g = blufiDH.g;
    NSData *k = blufiDH.publicKey;
    NSInteger pgkLength = p.length + g.length + k.length + 6;
    Byte bytes[] = {
        NegSecuritySetTotalLength,
        pgkLength >> 8 & 0xff,
        pgkLength & 0xff
    };
    BOOL posted = [self post:[NSData dataWithBytes:bytes length:3] encrypt:NO checksum:NO requireAck:_requireAck type:type];
    if (!posted) {
        NSLog(@"postNegotiateSecurity: Post length failed");
        return nil;
    }
    
    NSMutableData *data = [[NSMutableData alloc] initWithCapacity:pgkLength];
    Byte negType[] = {NegSecuritySetAllData};
    [data appendBytes:negType length:1];
    
    Byte pLength[] = {p.length >> 8 & 0xff, p.length & 0xff};
    [data appendBytes:pLength length:2];
    [data appendData:p];
    
    Byte gLength[] = {g.length >> 8 & 0xff, g.length & 0xff};
    [data appendBytes:gLength length:2];
    [data appendData:g];
    
    Byte kLength[] = {k.length >> 8 & 0xff, k.length & 0xff};
    [data appendBytes:kLength length:2];
    [data appendData:k];
    
    posted = [self post:data encrypt:NO checksum:NO requireAck:_requireAck type:type];
    if (!posted) {
        NSLog(@"postNegotiateSecurity: Post data failed");
        return nil;
    }
    
    return blufiDH;
}

- (BOOL)postSetSecurityCtrlEncrypted:(BOOL)ctrlEncrypted ctrlChecksum:(BOOL)ctrlChecksum dataEncrypted:(BOOL)dataEncrypted dataChecksum:(BOOL)dataChecksum {
    Byte type = [self getTypeValueWithPackageType:PackageCtrl subType:CtrlSubTypeSetSecurityMode];
    Byte data = 0;
    if (dataChecksum) {
        data |= 1;
    }
    if (dataEncrypted) {
        data |= 0b10;
    }
    if (ctrlChecksum) {
        data |= 0b10000;
    }
    if (ctrlEncrypted) {
        data |= 0b100000;
    }
    Byte postBytes[] = {data};
    NSData *postData = [NSData dataWithBytes:postBytes length:1];
    return [self post:postData encrypt:NO checksum:YES requireAck:_requireAck type:type];
}

- (void)onNegotiateSecurityResult:(BlufiStatusCode)code {
    id delegate = _blufiDelegate;
    BlufiClient *client = self;
    if (delegate && [delegate respondsToSelector:@selector(blufi:didNegotiateSecurity:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate blufi:client didNegotiateSecurity:code];
        }];
    }
}

- (void)negotiateSecurity {
    [_requestQueue addOperationWithBlock:^{
        BOOL setSecurity = NO;
        BlufiStatusCode code = StatusFailed;
        @try {
            BlufiDH *blufiDH = [self postNegotiateSecurity];
            if (!blufiDH) {
                code = StatusWriteFailed;
                return;
            }
            NSLog(@"negotiateSecurity DH posted");
            
            NSData *deviceKey = [self.deviceKey dequeue];
            if (!deviceKey) {
                NSLog(@"negotiateSecurity Recevie nil deviceKey");
                code = StatusFailed;
                return;
            }
            
            NSData *secretKey = [blufiDH generateSecret:deviceKey];
            self.aesKey = [BlufiSecurity md5:secretKey];
            if (DBUG) {
                NSLog(@"DH Secret = %@", secretKey);
                NSLog(@"AES Key   = %@", self.aesKey);
            }
            
            setSecurity = [self postSetSecurityCtrlEncrypted:NO ctrlChecksum:NO dataEncrypted:YES dataChecksum:YES];
            if (!setSecurity) {
                NSLog(@"negotiateSecurity postSetSecurity failed");
                code = StatusWriteFailed;
            }
        } @catch (NSException *exception) {
            NSLog(@"negotiateSecurity exception: %@", exception);
            code = StatusException;
        } @finally {
            if (setSecurity) {
                self.encrypted = YES;
                self.checksum = YES;
                [self onNegotiateSecurityResult:StatusSuccess];
            } else {
                self.encrypted = NO;
                self.checksum = NO;
                [self onNegotiateSecurityResult:code];
            }
        }
    }];
}

- (void)centralManagerDidUpdateState:(nonnull CBCentralManager *)central {
    _blePowerOn = central.state == CBManagerStatePoweredOn;
    if (_blePowerOn) {
        NSLog(@"Blufi Client BLE state pwoered on");
        if (_bleConnectMark) {
            _bleConnectMark = NO;
            [self scanBLE];
        }
    }
    id delegate = _centralManagerDelete;
    if (delegate) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate centralManagerDidUpdateState:central];
        }];
    }
}

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary<NSString *,id> *)advertisementData RSSI:(NSNumber *)RSSI {
//    NSLog(@"Per UUID: %@, %@", peripheral.name, peripheral.identifier.UUIDString)
    if ([peripheral.identifier isEqual:_identifier]) {
        [_centralManager stopScan];
        _peripheral = peripheral;
        _peripheral.delegate = self;
        
        [_centralManager connectPeripheral:peripheral options:nil];
    }
    
    // callback
    id delegate = _centralManagerDelete;
    if (delegate && [delegate respondsToSelector:@selector(centralManager:didDiscoverPeripheral:advertisementData:RSSI:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate centralManager:central didDiscoverPeripheral:peripheral advertisementData:advertisementData RSSI:RSSI];
        }];
    }
}

- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral {
    // Connect BLE successfully
    CBUUID *uuid = [CBUUID UUIDWithString:UUID_SERVICE];
    NSArray<CBUUID *> *filters = @[uuid];
    [peripheral discoverServices:filters];
    
    _connectState = StateConnected;
    // callback
    id delegate = _centralManagerDelete;
    if (delegate && [delegate respondsToSelector:@selector(centralManager:didConnectPeripheral:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate centralManager:central didConnectPeripheral:peripheral];
        }];
    }
}

- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error {
    // Connect BLE failed
    [self clearConnection];
    
    // callback
    id delegate = _centralManagerDelete;
    if (delegate && [delegate respondsToSelector:@selector(centralManager:didFailToConnectPeripheral:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate centralManager:central didFailToConnectPeripheral:peripheral error:error];
        }];
    }
}

- (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error {
    // Disconnect BLE
    [self clearConnection];
    
    // callback
    id delegate = _centralManagerDelete;
    if (delegate && [delegate respondsToSelector:@selector(centralManager:didDisconnectPeripheral:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate centralManager:central didDisconnectPeripheral:peripheral error:error];
        }];
    }
}

- (void)gattDiscoverCallback {
    id bDelegage = _blufiDelegate;
    if (bDelegage && [bDelegage respondsToSelector:@selector(blufi:gattPrepared:service:writeChar:notifyChar:)]) {
        BlufiClient *client = self;
        CBService *service = _service;
        CBCharacteristic *writeChar = _writeChar;
        CBCharacteristic *notifyChar = _notifyChar;
        BlufiStatusCode code = service && writeChar && notifyChar ? StatusSuccess : StatusFailed;
        [_callbackQueue addOperationWithBlock:^{
            [bDelegage blufi:client gattPrepared:code service:service writeChar:writeChar notifyChar:notifyChar];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {
    // Discover services
    if (error) {
        NSLog(@"didDiscoverServices error: %@", error);
        [self clearConnection];
        [self gattDiscoverCallback];
    } else {
        NSArray<CBService *> *services = [peripheral services];
        for (CBService *service in services) {
            if ([service.UUID.UUIDString isEqualToString:UUID_SERVICE]) {
                _service = service;
                break;
            }
        }
        if (_service) {
            CBService *service  = services[0];
            [peripheral discoverCharacteristics:nil forService:service];
            _service = service;
        } else {
            NSLog(@"didDiscoverServices failed");
            [self gattDiscoverCallback];
            [self clearConnection];
        }
    }
    
    // callback
    id deletgate = _peripheralDelegate;
    if (deletgate && [deletgate respondsToSelector:@selector(peripheral:didDiscoverServices:)]) {
        [deletgate peripheral:peripheral didDiscoverServices:error];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error {
    // Discover Characteristics
    if (error) {
        NSLog(@"didDiscoverCharacteristicsForService error: %@", error);
        [self gattDiscoverCallback];
        [self clearConnection];
    } else {
        CBCharacteristic *writeChar = nil;
        CBCharacteristic *notifyChar = nil;
        NSArray<CBCharacteristic *> *characteristics = [service characteristics];
        for (CBCharacteristic *c in characteristics) {
            if ([c.UUID isEqual:_writeUUID]) {
                NSLog(@"didDiscoverCharacteristicsForService get write char");
                writeChar = c;
            } else if ([c.UUID isEqual:_notifyUUID]) {
                NSLog(@"didDiscoverCharacteristicsForService get notify char");
                notifyChar = c;
            }
        }
        _writeChar = writeChar;
        _notifyChar = notifyChar;
        if (!writeChar || !notifyChar) {
            NSLog(@"didDiscoverCharacteristicsForService failed");
            [self gattDiscoverCallback];
            [self clearConnection];
        } else {
            [peripheral setNotifyValue:YES forCharacteristic:notifyChar];
        }
    }
    
    // callback
    id deletgate = _peripheralDelegate;
    if (deletgate && [deletgate respondsToSelector:@selector(peripheral:didDiscoverCharacteristicsForService:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [deletgate peripheral:peripheral didDiscoverCharacteristicsForService:service error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didUpdateNotificationStateForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
    // Set Notification
    if (error) {
        NSLog(@"didUpdateNotificationStateForCharacteristic error: %@", error);
        [self gattDiscoverCallback];
        [self clearConnection];
    } else {
            // Connection all ready
        [self gattDiscoverCallback];
    }
    
    // callback
    id pDelegete = _peripheralDelegate;
    if (pDelegete && [pDelegete respondsToSelector:@selector(peripheral:didUpdateNotificationStateForCharacteristic:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [pDelegete peripheral:peripheral didUpdateNotificationStateForCharacteristic:characteristic error:error];
        }];
    }
    
}

- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
    if (error) {
        NSLog(@"didUpdateValueForCharacteristic error: %@", error);
        [self clearConnection];
    } else {
        if (!_notifyData) {
            _notifyData = [[BlufiNotifyData alloc] init];
        }
        NSData *value = characteristic.value;
        NotifyStatus status = [self parseNotification:value notification:_notifyData];
        switch (status) {
            case NotifyComplete:
                [self parseBlufiNotifyData:_notifyData];
                _notifyData = nil;
                break;
            case NotifyHasFrag:
                NSLog(@"parseNotification wait next");
                break;
            default:
                NSLog(@"parseNotification failed");
                [self onError:StatusInvalidData];
                break;
        }
    }
    
    // callback
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didUpdateValueForCharacteristic:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didUpdateValueForCharacteristic:characteristic error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
    [_writeCondition lock];
    [_writeCondition signal];
    [_writeCondition unlock];
    if (error) {
        NSLog(@"didWriteValueForCharacteristic error: %@", error);
        [self clearConnection];
    }
    
    // callback
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didWriteValueForCharacteristic:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didWriteValueForCharacteristic:characteristic error:error];
        }];
    }
}


// Blufi unused delegate functions Start
// CBCentralManager delegate Start

//- (void)centralManager:(CBCentralManager *)central willRestoreState:(NSDictionary<NSString *,id> *)dict {
//    id delegate = _centralManagerDelete;
//    if (delegate && [delegate respondsToSelector:@selector(centralManager:willRestoreState:)]) {
//        [_callbackQueue addOperationWithBlock:^{
//            [delegate centralManager:central willRestoreState:dict];
//        }];
//    }
//}

- (void)centralManager:(CBCentralManager *)central connectionEventDidOccur:(CBConnectionEvent)event forPeripheral:(CBPeripheral *)peripheral {
    if (@available(iOS 13.0, *)) {
        id delegate = _centralManagerDelete;
        if (delegate && [delegate respondsToSelector:@selector(centralManager:connectionEventDidOccur:forPeripheral:)]) {
            [_callbackQueue addOperationWithBlock:^{
                [delegate centralManager:central connectionEventDidOccur:event forPeripheral:peripheral];
            }];
        }
    }
}

- (void)centralManager:(CBCentralManager *)central didUpdateANCSAuthorizationForPeripheral:(CBPeripheral *)peripheral {
    if (@available(iOS 13.0, *)) {
        id delegate = _centralManagerDelete;
        if (delegate && [delegate respondsToSelector:@selector(centralManager:didUpdateANCSAuthorizationForPeripheral:)]) {
            [_callbackQueue addOperationWithBlock:^{
                [delegate centralManager:central didUpdateANCSAuthorizationForPeripheral:peripheral];
            }];
        }
    }
}
// CBCentralManager delegate End

// CBPeripheral delegate Start
- (void)peripheralDidUpdateName:(CBPeripheral *)peripheral {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheralDidUpdateName:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheralDidUpdateName:peripheral];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didModifyServices:(NSArray<CBService *> *)invalidatedServices {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didModifyServices:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didModifyServices:invalidatedServices];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didReadRSSI:(NSNumber *)RSSI error:(NSError *)error {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didReadRSSI:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didReadRSSI:RSSI error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverIncludedServicesForService:(CBService *)service error:(NSError *)error {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didDiscoverIncludedServicesForService:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didDiscoverIncludedServicesForService:service error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverDescriptorsForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didDiscoverDescriptorsForCharacteristic:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didDiscoverDescriptorsForCharacteristic:characteristic error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForDescriptor:(CBDescriptor *)descriptor error:(NSError *)error {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didUpdateValueForDescriptor:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didUpdateValueForDescriptor:descriptor error:error];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForDescriptor:(CBDescriptor *)descriptor error:(NSError *)error {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didWriteValueForDescriptor:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didWriteValueForDescriptor:descriptor error:error];
        }];
    }
}

- (void)peripheralIsReadyToSendWriteWithoutResponse:(CBPeripheral *)peripheral {
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheralIsReadyToSendWriteWithoutResponse:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheralIsReadyToSendWriteWithoutResponse:peripheral];
        }];
    }
}

- (void)peripheral:(CBPeripheral *)peripheral didOpenL2CAPChannel:(CBL2CAPChannel *)channel error:(NSError *)error  API_AVAILABLE(ios(11.0)){
    id delegate = _peripheralDelegate;
    if (delegate && [delegate respondsToSelector:@selector(peripheral:didOpenL2CAPChannel:error:)]) {
        [_callbackQueue addOperationWithBlock:^{
            [delegate peripheral:peripheral didOpenL2CAPChannel:channel error:error];
        }];
    }
}
// CBPeripheral delegate End


// Blufi unused delegate functions End

@end

@interface EspBlockingQueue()

@property (nonatomic, strong) NSMutableArray *queue;
@property (nonatomic, strong) NSCondition *lock;
@property (nonatomic, strong) dispatch_queue_t dispatchQueue;

- (NSUInteger)count;

@end

@implementation EspBlockingQueue

- (id)init {
    self = [super init];
    if (self) {
        self.queue = [[NSMutableArray alloc] init];
        self.lock = [[NSCondition alloc] init];
        self.dispatchQueue = dispatch_queue_create("com.espressif.blufi", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)cancel {
    [_lock lock];
    [_lock signal];
    [_lock unlock];
}

- (void)enqueue:(id)object {
    [_lock lock];
    [_queue addObject:object];
    [_lock signal];
    [_lock unlock];
}

- (id)dequeue {
    __block id object;
    dispatch_sync(_dispatchQueue, ^{
        [self.lock lock];
        while (self.queue.count == 0) {
            [self.lock wait];
        }
        object = [self.queue objectAtIndex:0];
        [self.queue removeObjectAtIndex:0];
        [self.lock unlock];
    });
    NSLog(@"device details object %@",object);
    return object;
}

- (NSUInteger)count {
    return [_queue count];
}

- (void)dealloc {
    self.dispatchQueue = nil;
    self.queue = nil;
    self.lock = nil;
}

@end