import type { BleService, BleCharacteristic, BleDataReceivedCallback, BleCharacteristicProperties, WriteCharacteristicOptions, ByteArray } from '../interface.uts';
import BluetoothGatt from "android.bluetooth.BluetoothGatt";
import BluetoothGattService from "android.bluetooth.BluetoothGattService";
import BluetoothGattCharacteristic from "android.bluetooth.BluetoothGattCharacteristic";
import BluetoothGattDescriptor from "android.bluetooth.BluetoothGattDescriptor";
import BluetoothGattCallback from "android.bluetooth.BluetoothGattCallback";
import UUID from "java.util.UUID";
import { DeviceManager } from './device_manager.uts';
import { AkBleErrorImpl, AkBluetoothErrorCode } from '../unierror.uts';
import { AutoDiscoverAllResult } from '../interface.uts';
// 补全UUID格式，将短格式转换为标准格式
function getFullUuid(shortUuid: string): string {
    return `0000${shortUuid}-0000-1000-8000-00805f9b34fb`;
}
const deviceWriteQueues = new Map<string, Promise<void>>();
function enqueueDeviceWrite<T>(deviceId: string, work: () => Promise<T>): Promise<T> {
    const previous = deviceWriteQueues.get(deviceId) ?? Promise.resolve();
    const next = (async (): Promise<T> => {
        try {
            await previous;
        }
        catch (e: any) { /* ignore previous rejection to keep queue alive */ }
        return await work();
    })();
    const queued = next.then(() => { }, () => { });
    deviceWriteQueues.set(deviceId, queued);
    return next.finally(() => {
        if (deviceWriteQueues.get(deviceId) == queued) {
            deviceWriteQueues.delete(deviceId);
        }
    });
}
function createCharProperties(props: number): BleCharacteristicProperties {
    const result: BleCharacteristicProperties = {
        read: false,
        write: false,
        notify: false,
        indicate: false,
        canRead: false,
        canWrite: false,
        canNotify: false,
        writeWithoutResponse: false
    };
    result.read = (props & BluetoothGattCharacteristic.PROPERTY_READ) !== 0;
    result.write = (props & BluetoothGattCharacteristic.PROPERTY_WRITE) !== 0;
    result.notify = (props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) !== 0;
    result.indicate = (props & BluetoothGattCharacteristic.PROPERTY_INDICATE) !== 0;
    result.writeWithoutResponse = (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) !== 0;
    result.canRead = result.read;
    const writeWithoutResponse = result.writeWithoutResponse!;
    result.canWrite = (result.write != null && result.write) || (writeWithoutResponse != null && writeWithoutResponse);
    result.canNotify = result.notify;
    return result;
}
// 定义 PendingCallback 类型和实现类
interface PendingCallback {
    resolve: (data: any) => void;
    reject: (err?: any) => void;
    timer?: number; // Changed from any to number
}
class PendingCallbackImpl implements PendingCallback {
    override resolve: (data: any) => void;
    override reject: (err?: any) => void;
    override timer?: number; // Changed from any to number
    constructor(resolve: (data: any) => void, reject: (err?: any) => void, timer?: number) {
        this.resolve = resolve;
        this.reject = reject;
        this.timer = timer;
    }
}
// 全局回调管理（必须在类外部声明）
let pendingCallbacks: Map<string, PendingCallback>;
let notifyCallbacks: Map<string, BleDataReceivedCallback>;
// 在全局范围内初始化
pendingCallbacks = new Map<string, PendingCallback>();
notifyCallbacks = new Map<string, BleDataReceivedCallback>();
// 服务发现等待队列：deviceId -> 回调数组
const serviceDiscoveryWaiters = new Map<string, ((services: BleService[] | null, error?: Error) => void)[]>();
// 服务发现状态：deviceId -> 是否已发现
const serviceDiscovered = new Map<string, boolean>();
// 服务发现重试：deviceId -> 尝试次数
const serviceDiscoveryAttempts = new Map<string, number>();
const SERVICE_DISCOVERY_MAX_RETRIES = 3;
const SERVICE_DISCOVERY_RETRY_DELAY_MS = 600;
// 特征发现等待队列：deviceId|serviceId -> 回调数组
const characteristicDiscoveryWaiters = new Map<string, ((characteristics: BleCharacteristic[] | null, error?: Error) => void)[]>();
class GattCallback extends BluetoothGattCallback {
    constructor() {
        super();
    }
    override onServicesDiscovered(gatt: BluetoothGatt, status: Int): void {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:112', 'ak onServicesDiscovered',gatt);
        const deviceId = gatt.getDevice().getAddress();
        if (status == BluetoothGatt.GATT_SUCCESS) {
            const attempt = serviceDiscoveryAttempts.get(deviceId) ?? 0;
            const services = gatt.getServices();
            const result: BleService[] = [];
            let size = 0;
            if (services != null) {
                const servicesList = services;
                size = servicesList.size;
                for (let i = 0; i < size; i++) {
                    const service = servicesList.get(i as Int);
                    if (service != null) {
                        const bleService: BleService = {
                            uuid: service.getUuid().toString(),
                            isPrimary: service.getType() == BluetoothGattService.SERVICE_TYPE_PRIMARY
                        };
                        result.push(bleService);
                    }
                }
            }
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:133', '[ServiceManager] onServicesDiscovered size=', size, 'attempt=', attempt, 'device=', deviceId);
            if (result.length == 0 && attempt < SERVICE_DISCOVERY_MAX_RETRIES) {
                __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:135', '[ServiceManager] services empty after discovery, retrying', deviceId, 'nextAttempt=', attempt + 1);
                serviceDiscoveryAttempts.set(deviceId, attempt + 1);
                serviceDiscovered.delete(deviceId);
                setTimeout(() => {
                    try {
                        const dm = DeviceManager.getInstance();
                        const currentGatt = dm.getGattInstance(deviceId);
                        const target = currentGatt != null ? currentGatt : gatt;
                        if (target != null) {
                            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:144', '[ServiceManager] retry discoverServices for', deviceId);
                            target.discoverServices();
                        }
                    }
                    catch (e: any) {
                        __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:148', '[ServiceManager] retry discoverServices failed', e);
                    }
                }, SERVICE_DISCOVERY_RETRY_DELAY_MS);
                return;
            }
            let finalResult: BleService[] | null = result;
            if (result.length == 0) {
                const cached = ServiceManager.getInstance().getCachedServices(deviceId);
                if (cached != null && cached.length > 0) {
                    __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:154', '[ServiceManager] discovery returned empty, using cached services for', deviceId, 'len=', cached.length);
                    finalResult = cached;
                } else {
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:154', '[ServiceManager] discovery returned empty after retries for', deviceId);
                    serviceDiscoveryAttempts.delete(deviceId);
                    const waitersFail = serviceDiscoveryWaiters.get(deviceId);
                    if (waitersFail != null && waitersFail.length > 0) {
                        for (let i = 0; i < waitersFail.length; i++) {
                            const cb = waitersFail[i];
                            if (cb != null) {
                                cb(null, new Error('服务发现返回空列表'));
                            }
                        }
                        serviceDiscoveryWaiters.delete(deviceId);
                    }
                    return;
                }
            }
            serviceDiscoveryAttempts.delete(deviceId);
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:154', `服务发现成功: ${deviceId}, services=${finalResult != null ? finalResult.length : 0}`);
            serviceDiscovered.set(deviceId, true);
            ServiceManager.getInstance().handleServicesDiscovered(deviceId, finalResult ?? []);
            const waiters = serviceDiscoveryWaiters.get(deviceId);
            if (waiters != null && waiters.length > 0) {
                for (let i = 0; i < waiters.length; i++) {
                    const cb = waiters[i];
                    if (cb != null) {
                        cb(finalResult ?? [], null);
                    }
                }
                serviceDiscoveryWaiters.delete(deviceId);
            }
        }
        else {
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:166', `服务发现失败: ${deviceId}, status: ${status}`);
            serviceDiscoveryAttempts.delete(deviceId);
            // 失败时也要通知等待队列
            const waiters = serviceDiscoveryWaiters.get(deviceId);
            if (waiters != null && waiters.length > 0) {
                for (let i = 0; i < waiters.length; i++) {
                    const cb = waiters[i];
                    if (cb != null) {
                        cb(null, new Error('服务发现失败'));
                    }
                }
                serviceDiscoveryWaiters.delete(deviceId);
            }
        }
    }
    override onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int): void {
        const deviceId = gatt.getDevice().getAddress();
        if (newState == BluetoothGatt.STATE_CONNECTED) {
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:182', `设备已连接: ${deviceId}`);
            ServiceManager.getInstance().resetDiscoveryState(deviceId);
            DeviceManager.handleConnectionStateChange(deviceId, 2, null); // 2 = STATE_CONNECTED
        }
        else if (newState == BluetoothGatt.STATE_DISCONNECTED) {
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:186', `设备已断开: ${deviceId}`);
            serviceDiscovered.delete(deviceId);
            serviceDiscoveryAttempts.delete(deviceId);
            ServiceManager.getInstance().handleDisconnected(deviceId);
            DeviceManager.handleConnectionStateChange(deviceId, 0, null); // 0 = STATE_DISCONNECTED
        }
    }
    override onCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic): void {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:194', 'ak onCharacteristicChanged');
        const deviceId = gatt.getDevice().getAddress();
        const serviceId = characteristic.getService().getUuid().toString();
        const charId = characteristic.getUuid().toString();
        const key = `${deviceId}|${serviceId}|${charId}|notify`;
        const callback = notifyCallbacks.get(key);
        const value = characteristic.getValue();
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:201', '[onCharacteristicChanged]', key, value);
        // Check for PING packets (0xAA 0x04 0x00 ...)
        if (value != null && value.size >= 4) {
            const arr = new Uint8Array(value.size);
            for (let i = 0 as Int; i < value.size; i++) {
                const v = value[i as Int];
                arr[i] = v != null ? v : 0;
            }
            if (arr[0] === 0xAA && arr[2] === 0x00) {
                __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:201', '[BLE] PING packet detected:', Array.from(arr));
            }
        }
        if (callback != null && value != null) {
            const valueLength = value.size;
            const arr = new Uint8Array(valueLength);
            for (let i = 0 as Int; i < valueLength; i++) {
                const v = value[i as Int];
                arr[i] = v != null ? v : 0;
            }
            // 保存接收日志
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:210', `
          INSERT INTO ble_data_log (device_id, service_id, char_id, direction, data, timestamp)
          VALUES ('${deviceId}', '${serviceId}', '${charId}', 'recv', '${Array.from(arr).join(',')}', ${Date.now()})
        `);
            callback(arr);
        }
    }
    override onCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int): void {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:219', 'ak onCharacteristicRead', status);
        const deviceId = gatt.getDevice().getAddress();
        const serviceId = characteristic.getService().getUuid().toString();
        const charId = characteristic.getUuid().toString();
        const key = `${deviceId}|${serviceId}|${charId}|read`;
        const pending = pendingCallbacks.get(key);
        const value = characteristic.getValue();
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:226', '[onCharacteristicRead]', key, 'status=', status, 'value=', value);
        if (pending != null) {
            try {
                const timer = pending.timer;
                if (timer != null) {
                    clearTimeout(timer);
                    pending.timer = null;
                }
                pendingCallbacks.delete(key);
                if (status == BluetoothGatt.GATT_SUCCESS && value != null) {
                    const valueLength = value.size;
                    const arr = new Uint8Array(valueLength);
                    for (let i = 0 as Int; i < valueLength; i++) {
                        const v = value[i as Int];
                        arr[i] = v != null ? v : 0;
                    }
                    // debug: log raw bytes and decoded string (helpful on Android native path)
                    try {
                        const hex = Array.from(arr).map((b): string => b.toString(16).padStart(2, '0')).join(' ');
                        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:246', '[ServiceManager] onCharacteristicRead raw hex:', hex, 'len=', arr.length, 'key=', key);
                        try {
                            const decoded = new TextDecoder().decode(arr);
                            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:249', '[ServiceManager] onCharacteristicRead decoded string:', decoded);
                        }
                        catch (e: any) {
                            __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:250', '[ServiceManager] decode error', e);
                        }
                    }
                    catch (e: any) {
                        __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:251', '[ServiceManager] failed to log read buffer', e);
                    }
                    // resolve with ArrayBuffer
                    pending.resolve(arr.buffer as ArrayBuffer);
                }
                else {
                    pending.reject(new Error('Characteristic read failed'));
                }
            }
            catch (e: any) {
                try {
                    pending.reject(e);
                }
                catch (e2: any) {
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:259', e2);
                }
            }
        }
    }
    override onCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int): void {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:265', 'ak onCharacteristicWrite', status);
        const deviceId = gatt.getDevice().getAddress();
        const serviceId = characteristic.getService().getUuid().toString();
        const charId = characteristic.getUuid().toString();
        const key = `${deviceId}|${serviceId}|${charId}|write`;
        const pending = pendingCallbacks.get(key);
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:271', '[onCharacteristicWrite]', key, 'status=', status);
        if (pending != null) {
            try {
                const timer = pending.timer;
                if (timer != null) {
                    clearTimeout(timer);
                }
                pendingCallbacks.delete(key);
                if (status == BluetoothGatt.GATT_SUCCESS) {
                    pending.resolve('ok');
                }
                else {
                    pending.reject(new Error('Characteristic write failed'));
                }
            }
            catch (e: any) {
                try {
                    pending.reject(e);
                }
                catch (e2: any) {
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:285', e2);
                }
            }
        }
    }
}
// 导出单例实例供外部使用
export const gattCallback = new GattCallback();
export class ServiceManager {
    private static instance: ServiceManager | null = null;
    private services = new Map<string, BleService[]>();
    private characteristics = new Map<string, Map<string, BleCharacteristic[]>>();
    private deviceManager = DeviceManager.getInstance();
    private constructor() { }
    static getInstance(): ServiceManager {
        if (ServiceManager.instance == null) {
            ServiceManager.instance = new ServiceManager();
        }
        return ServiceManager.instance!;
    }
    public resetDiscoveryState(deviceId: string, clearServiceCache: boolean = false): void {
        serviceDiscoveryAttempts.delete(deviceId);
        serviceDiscovered.delete(deviceId);
        serviceDiscoveryWaiters.delete(deviceId);
        if (clearServiceCache == true) {
            this.services.delete(deviceId);
        }
    }
    public handleServicesDiscovered(deviceId: string, services: BleService[]): void {
        this.services.set(deviceId, services);
    }
    public getCachedServices(deviceId: string): BleService[] | null {
        const cached = this.services.get(deviceId);
        return cached != null ? cached : null;
    }
    public handleDisconnected(deviceId: string): void {
        this.resetDiscoveryState(deviceId);
        const keysToRemove: string[] = [];
        this.characteristics.forEach((_value, key) => {
            if (key != null && key.indexOf(deviceId + '|') == 0) {
                keysToRemove.push(key);
            }
        });
        for (let i = 0; i < keysToRemove.length; i++) {
            this.characteristics.delete(keysToRemove[i]);
        }
    }
    getServices(deviceId: string, callback?: (services: BleService[] | null, error?: Error) => void): any | Promise<BleService[]> {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts', 'ak start getservice', deviceId);
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null) {
            if (callback != null) {
                callback(null, new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", ""));
            }
            return Promise.reject(new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", ""));
        }
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts', 'ak serviceDiscovered', gatt);
        // 如果服务已发现，直接返回
        if (serviceDiscovered.get(deviceId) == true) {
            const services = gatt.getServices();
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:333', services);
            const result: BleService[] = [];
            if (services != null) {
                const servicesList = services;
                const size = servicesList.size;
                if (size > 0) {
                    for (let i = 0 as Int; i < size; i++) {
                        const service = servicesList != null ? servicesList.get(i) : servicesList[i];
                        if (service != null) {
                            const bleService: BleService = {
                                uuid: service.getUuid().toString(),
                                isPrimary: service.getType() == BluetoothGattService.SERVICE_TYPE_PRIMARY
                            };
                            result.push(bleService);
                            if (bleService.uuid == getFullUuid('0001')) {
                                const device = this.deviceManager.getDevice(deviceId);
                                if (device != null) {
                                    device.serviceId = bleService.uuid;
                                    this.getCharacteristics(deviceId, device.serviceId!, (chars, err) => {
                                        if (err == null && chars != null) {
                                            const writeChar = chars.find((c): boolean => c.uuid == getFullUuid('0010'));
                                            const notifyChar = chars.find((c): boolean => c.uuid == getFullUuid('0011'));
                                            if (writeChar != null)
                                                device.writeCharId = writeChar.uuid;
                                            if (notifyChar != null)
                                                device.notifyCharId = notifyChar.uuid;
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            }
            if (callback != null) {
                callback(result, null);
            }
            return Promise.resolve(result);
        }
        // 未发现则发起服务发现并加入等待队列
        if (!serviceDiscoveryWaiters.has(deviceId)) {
			console.log('ak should start serviceDiscoveryWaiters')
            serviceDiscoveryWaiters.set(deviceId, []);
            gatt.discoverServices();
        }
        return new Promise<BleService[]>((resolve, reject) => {
            const cb = (services: BleService[] | null, error?: Error) => {
                if (error != null)
                    reject(error);
                else
                    resolve(services ?? []);
                if (callback != null)
                    callback(services, error);
            };
            const arr = serviceDiscoveryWaiters.get(deviceId);
            if (arr != null)
                arr.push(cb);
        });
    }
    getCharacteristics(deviceId: string, serviceId: string, callback: (characteristics: BleCharacteristic[] | null, error?: Error) => void): void {
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null)
            return callback(null, new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", ""));
        // 如果服务还没发现，等待服务发现后再查特征
        if (serviceDiscovered.get(deviceId) !== true) {
            // 先注册到服务发现等待队列
            this.getServices(deviceId, (services, err) => {
                if (err != null) {
                    callback(null, err);
                }
                else {
                    this.getCharacteristics(deviceId, serviceId, callback);
                }
            });
            return;
        }
        // 服务已发现，正常获取特征
        const service = gatt.getService(UUID.fromString(serviceId));
        if (service == null)
            return callback(null, new AkBleErrorImpl(AkBluetoothErrorCode.ServiceNotFound, "Service not found", ""));
        const chars = service.getCharacteristics();
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:403', chars);
        const result: BleCharacteristic[] = [];
        if (chars != null) {
            const characteristicsList = chars;
            const size = characteristicsList.size;
            const bleService: BleService = {
                uuid: serviceId,
                isPrimary: service.getType() == BluetoothGattService.SERVICE_TYPE_PRIMARY
            };
            for (let i = 0 as Int; i < size; i++) {
                const char = characteristicsList != null ? characteristicsList.get(i as Int) : characteristicsList[i];
                if (char != null) {
                    const props = char.getProperties();
                    try {
                        const charUuid = char.getUuid() != null ? char.getUuid().toString() : '';
                        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:418', '[ServiceManager] characteristic uuid=', charUuid);
                    }
                    catch (e: any) {
                        __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:419', '[ServiceManager] failed to read char uuid', e);
                    }
                    __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:420', props);
                    const bleCharacteristic: BleCharacteristic = {
                        uuid: char.getUuid().toString(),
                        service: bleService,
                        properties: createCharProperties(props)
                    };
                    result.push(bleCharacteristic);
                }
            }
        }
        callback(result, null);
    }
    public async readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ArrayBuffer> {
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", "");
        const service = gatt.getService(UUID.fromString(serviceId));
        if (service == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.ServiceNotFound, "Service not found", "");
        const char = service.getCharacteristic(UUID.fromString(characteristicId));
        if (char == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.CharacteristicNotFound, "Characteristic not found", "");
        const key = `${deviceId}|${serviceId}|${characteristicId}|read`;
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:441', key);
        return new Promise<ArrayBuffer>((resolve, reject) => {
            const timer = setTimeout(() => {
                pendingCallbacks.delete(key);
                reject(new AkBleErrorImpl(AkBluetoothErrorCode.ConnectionTimeout, "Connection timeout", ""));
            }, 5000);
            const resolveAdapter = (data: any) => { __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:447', 'read resolve:', data); resolve(data as ArrayBuffer); };
            const rejectAdapter = (err?: any) => { reject(new AkBleErrorImpl(AkBluetoothErrorCode.UnknownError, "Unknown error occurred", "")); };
            pendingCallbacks.set(key, new PendingCallbackImpl(resolveAdapter, rejectAdapter, timer));
            if (gatt.readCharacteristic(char) == false) {
                clearTimeout(timer);
                pendingCallbacks.delete(key);
                reject(new AkBleErrorImpl(AkBluetoothErrorCode.UnknownError, "Unknown error occurred", ""));
            }
            else {
                __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:456', 'read should be succeed', key);
            }
        });
    }
    public async writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: Uint8Array, options?: WriteCharacteristicOptions): Promise<boolean> {
        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:462', '[writeCharacteristic] deviceId:', deviceId, 'serviceId:', serviceId, 'characteristicId:', characteristicId, 'data:', data);
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null) {
            __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:465', '[writeCharacteristic] gatt is null');
            throw new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", "");
        }
        const service = gatt.getService(UUID.fromString(serviceId));
        if (service == null) {
            __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:470', '[writeCharacteristic] service is null');
            throw new AkBleErrorImpl(AkBluetoothErrorCode.ServiceNotFound, "Service not found", "");
        }
        const char = service.getCharacteristic(UUID.fromString(characteristicId));
        if (char == null) {
            __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:475', '[writeCharacteristic] characteristic is null');
            throw new AkBleErrorImpl(AkBluetoothErrorCode.CharacteristicNotFound, "Characteristic not found", "");
        }
        const key = `${deviceId}|${serviceId}|${characteristicId}|write`;
        const wantsNoResponse = options != null && options.waitForResponse == false;
        let retryMaxAttempts = 20;
        let retryDelay = 100;
        let giveupTimeout = 20000;
        if (options != null) {
            try {
                if (options.maxAttempts != null) {
                    const parsedAttempts = Math.floor(options.maxAttempts as number);
                    if (!isNaN(parsedAttempts) && parsedAttempts > 0)
                        retryMaxAttempts = parsedAttempts;
                }
            }
            catch (e: any) { }
            try {
                if (options.retryDelayMs != null) {
                    const parsedDelay = Math.floor(options.retryDelayMs as number);
                    if (!isNaN(parsedDelay) && parsedDelay >= 0)
                        retryDelay = parsedDelay;
                }
            }
            catch (e: any) { }
            try {
                if (options.giveupTimeoutMs != null) {
                    const parsedGiveup = Math.floor(options.giveupTimeoutMs as number);
                    if (!isNaN(parsedGiveup) && parsedGiveup > 0)
                        giveupTimeout = parsedGiveup;
                }
            }
            catch (e: any) { }
        }
        const gattInstance = gatt;
        const executeWrite = (): Promise<boolean> => {
            return new Promise<boolean>((resolve, _reject) => {
                const initialTimeout = Math.max(giveupTimeout + 5000, 10000);
                let timer = setTimeout(() => {
                    pendingCallbacks.delete(key);
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:510', '[writeCharacteristic] timeout');
                    resolve(false);
                }, initialTimeout);
                __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:513', '[writeCharacteristic] initial timeout set to', initialTimeout, 'ms for', key);
                const resolveAdapter = (data: any) => {
                    __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:515', '[writeCharacteristic] resolveAdapter called');
                    resolve(true);
                };
                const rejectAdapter = (err?: any) => {
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:519', '[writeCharacteristic] rejectAdapter called', err);
                    resolve(false);
                };
                pendingCallbacks.set(key, new PendingCallbackImpl(resolveAdapter, rejectAdapter, timer));
                const byteArray = new ByteArray(data.length as Int);
                for (let i = 0 as Int; i < data.length; i++) {
                    byteArray[i] = data[i].toByte();
                }
                const forceWriteTypeNoResponse = options != null && options.forceWriteTypeNoResponse == true;
                let usesNoResponse = forceWriteTypeNoResponse || wantsNoResponse;
                try {
                    if (usesNoResponse == false) {
                        const props = char.getProperties();
                        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:532', '[writeCharacteristic] characteristic properties mask=', props);
                        usesNoResponse = (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) !== 0;
                    }
                    if (usesNoResponse) {
                        try {
                            char.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
                        }
                        catch (e: any) { }
                        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:537', '[writeCharacteristic] using WRITE_TYPE_NO_RESPONSE');
                    }
                    else {
                        try {
                            char.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
                        }
                        catch (e: any) { }
                        __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:540', '[writeCharacteristic] using WRITE_TYPE_DEFAULT');
                    }
                }
                catch (e: any) {
                    __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:543', '[writeCharacteristic] failed to inspect/set write type', e);
                }
                const maxAttempts = retryMaxAttempts;
                function attemptWrite(att: Int): void {
                    try {
                        let setOk = true;
                        try {
                            const setRes = char.setValue(byteArray);
                            if (typeof setRes == 'boolean' && setRes == false) {
                                setOk = false;
                                __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:553', '[writeCharacteristic] setValue returned false for', key, 'attempt', att);
                            }
                        }
                        catch (e: any) {
                            setOk = false;
                            __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:557', '[writeCharacteristic] setValue threw for', key, 'attempt', att, e);
                        }
                        if (setOk == false) {
                            if (att >= maxAttempts) {
                                try {
                                    clearTimeout(timer);
                                }
                                catch (e: any) { }
                                pendingCallbacks.delete(key);
                                resolve(false);
                                return;
                            }
                            setTimeout(() => { attemptWrite((att + 1) as Int); }, retryDelay);
                            return;
                        }
                        try {
                            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:570', '[writeCharacteristic] attempt', att, 'calling gatt.writeCharacteristic');
                            const r = gattInstance.writeCharacteristic(char);
                            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:572', '[writeCharacteristic] attempt', att, 'result=', r);
                            if (r == true) {
                                if (usesNoResponse) {
                                    __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:575', '[writeCharacteristic] WRITE_TYPE_NO_RESPONSE success for', key);
                                    try {
                                        clearTimeout(timer);
                                    }
                                    catch (e: any) { }
                                    pendingCallbacks.delete(key);
                                    resolve(true);
                                    return;
                                }
                                try {
                                    clearTimeout(timer);
                                }
                                catch (e: any) { }
                                const extra = 20000;
                                timer = setTimeout(() => {
                                    pendingCallbacks.delete(key);
                                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:585', '[writeCharacteristic] timeout after write initiated');
                                    resolve(false);
                                }, extra);
                                const pendingEntry = pendingCallbacks.get(key);
                                if (pendingEntry != null)
                                    pendingEntry.timer = timer;
                                return;
                            }
                        }
                        catch (e: any) {
                            __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:593', '[writeCharacteristic] attempt', att, 'exception when calling writeCharacteristic', e);
                        }
                        if (att < maxAttempts) {
                            const nextAtt = (att + 1) as Int;
                            setTimeout(() => { attemptWrite(nextAtt); }, retryDelay);
                            return;
                        }
                        if (usesNoResponse) {
                            try {
                                clearTimeout(timer);
                            }
                            catch (e: any) { }
                            pendingCallbacks.delete(key);
                            __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:603', '[writeCharacteristic] all attempts failed with WRITE_NO_RESPONSE for', key);
                            resolve(false);
                            return;
                        }
                        try {
                            clearTimeout(timer);
                        }
                        catch (e: any) { }
                        const giveupTimeoutLocal = giveupTimeout;
                        __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:609', '[writeCharacteristic] all attempts failed; waiting for late callback up to', giveupTimeoutLocal, 'ms for', key);
                        const giveupTimer = setTimeout(() => {
                            pendingCallbacks.delete(key);
                            __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:612', '[writeCharacteristic] giveup timeout expired for', key);
                            resolve(false);
                        }, giveupTimeoutLocal);
                        const pendingEntryAfter = pendingCallbacks.get(key);
                        if (pendingEntryAfter != null)
                            pendingEntryAfter.timer = giveupTimer;
                    }
                    catch (e: any) {
                        clearTimeout(timer);
                        pendingCallbacks.delete(key);
                        __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:620', '[writeCharacteristic] Exception in attemptWrite', e);
                        resolve(false);
                    }
                }
                try {
                    attemptWrite(1 as Int);
                }
                catch (e: any) {
                    clearTimeout(timer);
                    pendingCallbacks.delete(key);
                    __f__('error', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:630', '[writeCharacteristic] Exception before attempting write', e);
                    resolve(false);
                }
            });
        };
        return enqueueDeviceWrite(deviceId, executeWrite);
    }
    public async subscribeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, onData: BleDataReceivedCallback): Promise<void> {
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", "");
        const service = gatt.getService(UUID.fromString(serviceId));
        if (service == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.ServiceNotFound, "Service not found", "");
        const char = service.getCharacteristic(UUID.fromString(characteristicId));
        if (char == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.CharacteristicNotFound, "Characteristic not found", "");
        const key = `${deviceId}|${serviceId}|${characteristicId}|notify`;
        notifyCallbacks.set(key, onData);
        if (gatt.setCharacteristicNotification(char, true) == false) {
            notifyCallbacks.delete(key);
            throw new AkBleErrorImpl(AkBluetoothErrorCode.UnknownError, "Failed to unsubscribe characteristic", "");
        }
        else {
            // 写入 CCCD 描述符，启用 notify
            const descriptor = char.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
            if (descriptor != null) {
                // 设置描述符值
                const value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;
                descriptor.setValue(value);
                const writedescript = gatt.writeDescriptor(descriptor);
                __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:660', 'subscribeCharacteristic: CCCD written for notify', writedescript);
            }
            else {
                __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:662', 'subscribeCharacteristic: CCCD descriptor not found!');
            }
            __f__('log', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:664', 'subscribeCharacteristic ok!!');
        }
    }
    public async unsubscribeCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<void> {
        const gatt = this.deviceManager.getGattInstance(deviceId);
        if (gatt == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.DeviceNotFound, "Device not found", "");
        const service = gatt.getService(UUID.fromString(serviceId));
        if (service == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.ServiceNotFound, "Service not found", "");
        const char = service.getCharacteristic(UUID.fromString(characteristicId));
        if (char == null)
            throw new AkBleErrorImpl(AkBluetoothErrorCode.CharacteristicNotFound, "Characteristic not found", "");
        const key = `${deviceId}|${serviceId}|${characteristicId}|notify`;
        notifyCallbacks.delete(key);
        if (gatt.setCharacteristicNotification(char, false) == false) {
            throw new AkBleErrorImpl(AkBluetoothErrorCode.UnknownError, "Failed to unsubscribe characteristic", "");
        }
    }
    // 自动发现所有服务和特征
    public async autoDiscoverAll(deviceId: string): Promise<AutoDiscoverAllResult> {
        const services = await this.getServices(deviceId, null) as BleService[];
        const allCharacteristics: BleCharacteristic[] = [];
        for (const service of services) {
            await new Promise<void>((resolve, reject) => {
                this.getCharacteristics(deviceId, service.uuid, (chars, err) => {
                    if (err != null)
                        reject(err);
                    else {
                        if (chars != null)
                            allCharacteristics.push(...chars);
                        resolve(void 0);
                    }
                });
            });
        }
        return { services, characteristics: allCharacteristics } as AutoDiscoverAllResult;
    }
    // 自动订阅所有支持 notify/indicate 的特征
    public async subscribeAllNotifications(deviceId: string, onData: BleDataReceivedCallback): Promise<void> {
        const { services, characteristics } = await this.autoDiscoverAll(deviceId);
        for (const char of characteristics) {
            if (char.properties.notify || char.properties.indicate) {
                try {
                    await this.subscribeCharacteristic(deviceId, char.service.uuid, char.uuid, onData);
                }
                catch (e: any) {
                    // 可以选择忽略单个特征订阅失败
                    __f__('warn', 'at uni_modules/ak-sbsrv/utssdk/app-android/service_manager.uts:710', `订阅特征 ${char.uuid} 失败:`, e);
                }
            }
        }
    }
}
//# sourceMappingURL=service_manager.uts.map