import { BleService } from '../interface.uts'
import type { WriteCharacteristicOptions, DfuOptions, ControlParserResult } from '../interface.uts'
import { DeviceManager } from './device_manager.uts'
import { ServiceManager } from './service_manager.uts'
import BluetoothGatt from 'android.bluetooth.BluetoothGatt'
import BluetoothGattCharacteristic from 'android.bluetooth.BluetoothGattCharacteristic'
import BluetoothGattDescriptor from 'android.bluetooth.BluetoothGattDescriptor'
import UUID from 'java.util.UUID'

// 通用 Nordic DFU UUIDs (常见设备可能使用这些；如厂商自定义请替换)
const DFU_SERVICE_UUID = '0000fe59-0000-1000-8000-00805f9b34fb'
const DFU_CONTROL_POINT_UUID = '8ec90001-f315-4f60-9fb8-838830daea50'
const DFU_PACKET_UUID = '8ec90002-f315-4f60-9fb8-838830daea50'

type DfuSession = {
	resolve : () => void;
	reject : (err ?: any) => void;
	onProgress ?: (p : number) => void;
	onLog ?: (s : string) => void;
	controlParser ?: (data : Uint8Array) => ControlParserResult | null;
	// Nordic 专用字段
	bytesSent ?: number;
	totalBytes ?: number;
	useNordic ?: boolean;
	// PRN (packet receipt notification) support
	prn ?: number;
	packetsSincePrn ?: number;
	prnResolve ?: () => void;
	prnReject ?: (err ?: any) => void;
}



export class DfuManager {
	// 会话表，用于把 control-point 通知路由到当前 DFU 流程
	private sessions : Map<string, DfuSession> = new Map();

	// 简化：只实现最基本的 GATT-based DFU 上传逻辑，需按设备协议调整 control point 的命令/解析

	// Emit a DFU lifecycle event for a session. name should follow Nordic listener names
	private _emitDfuEvent(deviceId : string, name : string, payload ?: any) {
		console.log('[DFU][Event]', name, deviceId, payload ?? '');
		const s = this.sessions.get(deviceId);
		if (s == null) return;
		if (typeof s.onLog == 'function') {
			try {
				const logFn = s.onLog as (msg : string) => void;
				logFn(`[${name}] ${payload != null ? JSON.stringify(payload) : ''}`);
			} catch (e) { }
		}
		if (name == 'onProgress' && typeof s.onProgress == 'function' && typeof payload == 'number') {
			try { s.onProgress(payload); } catch (e) { }
		}
	}

	async startDfu(deviceId : string, firmwareBytes : Uint8Array, options ?: DfuOptions) : Promise<void> {
		console.log('startDfu 0')
		const deviceManager = DeviceManager.getInstance();
		const serviceManager = ServiceManager.getInstance();
        console.log('startDfu 1')
		const gatt : BluetoothGatt | null = deviceManager.getGattInstance(deviceId);
		console.log('startDfu 2')
		if (gatt == null) throw new Error('Device not connected');
		console.log('[DFU] startDfu start deviceId=', deviceId, 'firmwareBytes=', firmwareBytes != null ? firmwareBytes.length : 0, 'options=', options);
		try {
			console.log('[DFU] requesting high connection priority for', deviceId);
			gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH);
		} catch (e) {
			console.warn('[DFU] requestConnectionPriority failed', e);
		}

		// 发现服务并特征
		// ensure services discovered before accessing GATT; serviceManager exposes Promise-based API
		await serviceManager.getServices(deviceId, null);
		console.log('[DFU] services ensured for', deviceId);
		const dfuService = gatt.getService(UUID.fromString(DFU_SERVICE_UUID));
		if (dfuService == null) throw new Error('DFU service not found');
		const controlChar = dfuService.getCharacteristic(UUID.fromString(DFU_CONTROL_POINT_UUID));
		const packetChar = dfuService.getCharacteristic(UUID.fromString(DFU_PACKET_UUID));
		console.log('[DFU] dfuService=', dfuService != null ? dfuService.getUuid().toString() : null, 'controlChar=', controlChar != null ? controlChar.getUuid().toString() : null, 'packetChar=', packetChar != null ? packetChar.getUuid().toString() : null);
		if (controlChar == null || packetChar == null) throw new Error('DFU characteristics missing');
		const packetProps = packetChar.getProperties();
		const supportsWriteWithResponse = (packetProps & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0;
		const supportsWriteNoResponse = (packetProps & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0;
		console.log('[DFU] packet characteristic props mask=', packetProps, 'supportsWithResponse=', supportsWriteWithResponse, 'supportsNoResponse=', supportsWriteNoResponse);

	// Allow caller to request a desired MTU via options for higher throughput
	const desiredMtu = (options != null && typeof options.mtu == 'number') ? options.mtu : 247;
		try {
			console.log('[DFU] requesting MTU=', desiredMtu, 'for', deviceId);
			await this._requestMtu(gatt, desiredMtu, 8000);
			console.log('[DFU] requestMtu completed for', deviceId);
		} catch (e) {
			console.warn('[DFU] requestMtu failed or timed out, continue with default.', e);
		}
		const mtu = desiredMtu; // 假定成功或使用期望值
	const chunkSize = Math.max(20, mtu - 3);

		// small helper to convert a byte (possibly signed) to a two-digit hex string
		const byteToHex = (b : number) => {
			const v = (b < 0) ? (b + 256) : b;
			let s = v.toString(16);
			if (s.length < 2) s = '0' + s;
			return s;
		};

	// Parameterize PRN window and timeout via options early so they are available
		// for session logging. Defaults: prn = 12 packets, prnTimeoutMs = 10000 ms
		let prnWindow = 0;
		if (options != null && typeof options.prn == 'number') {
			prnWindow = Math.max(0, Math.floor(options.prn));
		}
		const prnTimeoutMs = (options != null && typeof options.prnTimeoutMs == 'number') ? Math.max(1000, Math.floor(options.prnTimeoutMs)) : 8000;
		const disablePrnOnTimeout = !(options != null && options.disablePrnOnTimeout == false);

		// 订阅 control point 通知并将通知路由到会话处理器
		const controlHandler = (data : Uint8Array) => {
			// 交给会话处理器解析并触发事件
			try {
				const hexParts: string[] = [];
				for (let i = 0; i < data.length; i++) {
					const v = data[i] as number;
					hexParts.push(byteToHex(v));
				}
				const hex = hexParts.join(' ');
				console.log('[DFU] control notification callback invoked for', deviceId, 'raw=', Array.from(data), 'hex=', hex);
			} catch (e) {
				console.log('[DFU] control notification callback invoked for', deviceId, 'raw=', Array.from(data));
			}
			this._handleControlNotification(deviceId, data);
		};
		console.log('[DFU] subscribing control point for', deviceId);
		await serviceManager.subscribeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID, controlHandler);
		console.log('[DFU] subscribeCharacteristic returned for', deviceId);

		// 保存会话回调（用于 waitForControlEvent）; 支持 Nordic 模式追踪已发送字节
		this.sessions.set(deviceId, {
			resolve: () => { },
			reject: (err ?: any) => {console.log(err) },
			onProgress: null,
			onLog: null,
			controlParser: (data : Uint8Array) => this._defaultControlParser(data),
			bytesSent: 0,
			totalBytes: firmwareBytes.length,
			useNordic: options != null && options.useNordic == true,
			prn: null,
			packetsSincePrn: 0,
			prnResolve: null,
			prnReject: null
		});
		console.log('[DFU] session created for', deviceId, 'totalBytes=', firmwareBytes.length);
		console.log('[DFU] DFU session details:', { deviceId: deviceId, totalBytes: firmwareBytes.length, chunkSize: chunkSize, prnWindow: prnWindow, prnTimeoutMs: prnTimeoutMs });

		// wire options callbacks into the session (if provided)
		const sessRef = this.sessions.get(deviceId);
		if (sessRef != null) {
			sessRef.onProgress = (options != null && typeof options.onProgress == 'function') ? options.onProgress : null;
			sessRef.onLog = (options != null && typeof options.onLog == 'function') ? options.onLog : null;
		}

		// emit initial lifecycle events (Nordic-like)
	this._emitDfuEvent(deviceId, 'onDeviceConnecting', null);

		// 写入固件数据（非常保守的实现：逐包写入并等待短延迟）
		// --- PRN setup (optional, Nordic-style flow) ---
		// Parameterize PRN window and timeout via options: options.prn, options.prnTimeoutMs
		// Defaults were set earlier; build PRN payload using arithmetic to avoid
		// bitwise operators which don't map cleanly to generated Kotlin.
		if (prnWindow > 0) {
			try {
				// send Set PRN to device (format: [OP_CODE_SET_PRN, prn LSB, prn MSB])
				// WARNING: Ensure your device uses the same opcode/format; change if needed.
				const prnLsb = prnWindow % 256;
				const prnMsb = Math.floor(prnWindow / 256) % 256;
				const prnPayload = new Uint8Array([0x02, prnLsb, prnMsb]);
				await serviceManager.writeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID, prnPayload, null);
				const sess0 = this.sessions.get(deviceId);
				if (sess0 != null) {
					sess0.useNordic = true;
					sess0.prn = prnWindow;
					sess0.packetsSincePrn = 0;
					sess0.controlParser = (data : Uint8Array) => this._nordicControlParser(data);
				}
				console.log('[DFU] Set PRN sent (prn=', prnWindow, ') for', deviceId);
			} catch (e) {
				console.warn('[DFU] Set PRN failed (continuing without PRN):', e);
				const sessFallback = this.sessions.get(deviceId);
				if (sessFallback != null) sessFallback.prn = 0;
			}
		} else {
			console.log('[DFU] PRN disabled (prnWindow=', prnWindow, ') for', deviceId);
		}

	// 写入固件数据（逐包写入并根据 options.waitForResponse 选择是否等待响应）
		let offset = 0;
		const total = firmwareBytes.length;
	this._emitDfuEvent(deviceId, 'onDfuProcessStarted', null);
	this._emitDfuEvent(deviceId, 'onUploadingStarted', null);
		// Track outstanding write operations when using fire-and-forget mode so we can
		// log and throttle if the Android stack becomes overwhelmed.
		let outstandingWrites = 0;
		// read tuning parameters from options in a safe, generator-friendly way
		let configuredMaxOutstanding = 2;
		let writeSleepMs = 0;
		let writeRetryDelay = 100;
		let writeMaxAttempts = 12;
		let writeGiveupTimeout = 60000;
		let drainOutstandingTimeout = 3000;
		let failureBackoffMs = 0;

		// throughput measurement
		let throughputWindowBytes = 0;
		let lastThroughputTime = Date.now();
		function _logThroughputIfNeeded(force ?: boolean) {
			try {
				const now = Date.now();
				const elapsed = now - lastThroughputTime;
				if (force == true || elapsed >= 1000) {
					const bytes = throughputWindowBytes;
					const bps = Math.floor((bytes * 1000) / Math.max(1, elapsed));
					// reset window
					throughputWindowBytes = 0;
					lastThroughputTime = now;
					const human = `${bps} B/s`;
					console.log('[DFU] throughput:', human, 'elapsedMs=', elapsed);
					const s = this.sessions.get(deviceId);
					if (s != null && typeof s.onLog == 'function') {
						try { s.onLog?.invoke('[DFU] throughput: ' + human); } catch (e) { }
					}
				}
			} catch (e) { }
		}

		function _safeErr(e ?: any) {
			try {
				if (e == null) return '';
				if (typeof e == 'string') return e;
				try { return JSON.stringify(e); } catch (e2) { }
				try { return (e as any).toString(); } catch (e3) { }
				return '';
			} catch (e4) { return ''; }
		}
		try {
			if (options != null) {
				try {
					if (options.maxOutstanding != null) {
						const parsed = Math.floor(options.maxOutstanding as number);
						if (!isNaN(parsed) && parsed > 0) configuredMaxOutstanding = parsed;
					}
				} catch (e) { }
				try {
					if (options.writeSleepMs != null) {
						const parsedWs = Math.floor(options.writeSleepMs as number);
						if (!isNaN(parsedWs) && parsedWs >= 0) writeSleepMs = parsedWs;
					}
				} catch (e) { }
				try {
					if (options.writeRetryDelayMs != null) {
						const parsedRetry = Math.floor(options.writeRetryDelayMs as number);
						if (!isNaN(parsedRetry) && parsedRetry >= 0) writeRetryDelay = parsedRetry;
					}
				} catch (e) { }
				try {
					if (options.writeMaxAttempts != null) {
						const parsedAttempts = Math.floor(options.writeMaxAttempts as number);
						if (!isNaN(parsedAttempts) && parsedAttempts > 0) writeMaxAttempts = parsedAttempts;
					}
				} catch (e) { }
				try {
					if (options.writeGiveupTimeoutMs != null) {
						const parsedGiveupTimeout = Math.floor(options.writeGiveupTimeoutMs as number);
						if (!isNaN(parsedGiveupTimeout) && parsedGiveupTimeout > 0) writeGiveupTimeout = parsedGiveupTimeout;
					}
				} catch (e) { }
				try {
					if (options.drainOutstandingTimeoutMs != null) {
						const parsedDrain = Math.floor(options.drainOutstandingTimeoutMs as number);
						if (!isNaN(parsedDrain) && parsedDrain >= 0) drainOutstandingTimeout = parsedDrain;
					}
				} catch (e) { }
			}
			if (configuredMaxOutstanding < 1) configuredMaxOutstanding = 1;
			if (writeSleepMs < 0) writeSleepMs = 0;
		} catch (e) { }
			if (supportsWriteWithResponse == false && supportsWriteNoResponse == true) {
				if (configuredMaxOutstanding > 1) configuredMaxOutstanding = 1;
				if (writeSleepMs < 15) writeSleepMs = 15;
				if (writeRetryDelay < 150) writeRetryDelay = 150;
				if (writeMaxAttempts < 40) writeMaxAttempts = 40;
				if (writeGiveupTimeout < 120000) writeGiveupTimeout = 120000;
				console.log('[DFU] packet char only supports WRITE_NO_RESPONSE; serializing writes with conservative pacing');
			}
		const maxOutstandingCeiling = configuredMaxOutstanding;
		let adaptiveMaxOutstanding = configuredMaxOutstanding;
		const minOutstandingWindow = 1;

		while (offset < total) {
			const end = Math.min(offset + chunkSize, total);
			const slice = firmwareBytes.subarray(offset, end);
			// Decide whether to wait for response per-chunk. Honor characteristic support.
			// Generator-friendly: avoid 'undefined' and use explicit boolean check.
			let finalWaitForResponse = true;
			if (options != null) {
				try {
					const maybe = options.waitForResponse;
					if (maybe == true && supportsWriteWithResponse == false && supportsWriteNoResponse == true) {
						// caller requested response but characteristic cannot provide it; keep true to ensure we await the write promise.
						finalWaitForResponse = true;
					} else if (maybe == false) {
						finalWaitForResponse = false;
					} else if (maybe == true) {
						finalWaitForResponse = true;
					}
				} catch (e) { finalWaitForResponse = true; }
			}

			const writeOpts: WriteCharacteristicOptions = {
				waitForResponse: finalWaitForResponse,
				retryDelayMs: writeRetryDelay,
				maxAttempts: writeMaxAttempts,
				giveupTimeoutMs: writeGiveupTimeout,
				forceWriteTypeNoResponse: finalWaitForResponse == false
			};
			console.log('[DFU] writing packet chunk offset=', offset, 'len=', slice.length, 'waitForResponse=', finalWaitForResponse, 'outstanding=', outstandingWrites);

			// Fire-and-forget path: do not await the write if waitForResponse == false.
			if (finalWaitForResponse == false) {
				if (failureBackoffMs > 0) {
					console.log('[DFU] applying failure backoff', failureBackoffMs, 'ms before next write for', deviceId);
					await this._sleep(failureBackoffMs);
					failureBackoffMs = Math.floor(failureBackoffMs / 2);
				}
				while (outstandingWrites >= adaptiveMaxOutstanding) {
					await this._sleep(Math.max(1, writeSleepMs));
				}
				// increment outstanding counter and kick the write without awaiting.
				outstandingWrites = outstandingWrites + 1;
				// fire-and-forget: start the write but don't await its Promise
				const writeOffset = offset;
				serviceManager.writeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_PACKET_UUID, slice, writeOpts).then((res) => {
					outstandingWrites = Math.max(0, outstandingWrites - 1);
					if (res == true) {
						if (adaptiveMaxOutstanding < maxOutstandingCeiling) {
							adaptiveMaxOutstanding = Math.min(maxOutstandingCeiling, adaptiveMaxOutstanding + 1);
						}
						if (failureBackoffMs > 0) failureBackoffMs = Math.floor(failureBackoffMs / 2);
					}
					// log occasional completions
					if ((outstandingWrites & 0x1f) == 0) {
						console.log('[DFU] write completion callback, outstandingWrites=', outstandingWrites, 'adaptiveWindow=', adaptiveMaxOutstanding, 'device=', deviceId);
					}
					// detect write failure signaled by service manager
					if (res !== true) {
						adaptiveMaxOutstanding = Math.max(minOutstandingWindow, Math.floor(adaptiveMaxOutstanding / 2));
						failureBackoffMs = Math.min(200, Math.max(failureBackoffMs, Math.max(5, writeRetryDelay)));
						console.error('[DFU] writeCharacteristic returned false for device=', deviceId, 'offset=', writeOffset, 'adaptiveWindow now=', adaptiveMaxOutstanding);
						try { this._emitDfuEvent(deviceId, 'onError', { phase: 'write', offset: writeOffset, reason: 'write returned false' }); } catch (e) { }
					}
				}).catch((e) => {
					outstandingWrites = Math.max(0, outstandingWrites - 1);
					adaptiveMaxOutstanding = Math.max(minOutstandingWindow, Math.floor(adaptiveMaxOutstanding / 2));
					failureBackoffMs = Math.min(200, Math.max(failureBackoffMs, Math.max(5, writeRetryDelay)));
					console.warn('[DFU] fire-and-forget write failed for device=', deviceId, e, 'adaptiveWindow now=', adaptiveMaxOutstanding);
					try {
						const errMsg ='[DFU] fire-and-forget write failed for device=';
						this._emitDfuEvent(deviceId, 'onError', { phase: 'write', offset: writeOffset, reason: errMsg });
					} catch (e2) { }
				});
				// account bytes for throughput
				throughputWindowBytes += slice.length;
				_logThroughputIfNeeded(false);
			} else {
				console.log('[DFU] awaiting write for chunk offset=', offset);
				try {
					const writeResult = await serviceManager.writeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_PACKET_UUID, slice, writeOpts);
					if (writeResult !== true) {
						console.error('[DFU] writeCharacteristic(await) returned false at offset=', offset, 'device=', deviceId);
						try { this._emitDfuEvent(deviceId, 'onError', { phase: 'write', offset: offset, reason: 'write returned false' }); } catch (e) { }
						// abort DFU by throwing
						throw new Error('write failed');
					}
				} catch (e) {
					console.error('[DFU] awaiting write failed at offset=', offset, 'device=', deviceId, e);
					try {
						const errMsg = '[DFU] awaiting write failed ';
						this._emitDfuEvent(deviceId, 'onError', { phase: 'write', offset: offset, reason: errMsg });
					} catch (e2) { }
					throw e;
				}
				// account bytes for throughput
				throughputWindowBytes += slice.length;
				_logThroughputIfNeeded(false);
			}
			// update PRN counters and wait when window reached
			const sessAfter = this.sessions.get(deviceId);
			if (sessAfter != null && sessAfter.useNordic == true && typeof sessAfter.prn == 'number' && (sessAfter.prn ?? 0) > 0) {
				sessAfter.packetsSincePrn = (sessAfter.packetsSincePrn ?? 0) + 1;
				if ((sessAfter.packetsSincePrn ?? 0) >= (sessAfter.prn ?? 0) && (sessAfter.prn ?? 0) > 0) {
					// wait for PRN (device notification) before continuing
					try {
						console.log('[DFU] reached PRN window, waiting for PRN for', deviceId, 'packetsSincePrn=', sessAfter.packetsSincePrn, 'prn=', sessAfter.prn);
						await this._waitForPrn(deviceId, prnTimeoutMs);
						console.log('[DFU] PRN received, resuming transfer for', deviceId);
					} catch (e) {
						console.warn('[DFU] PRN wait failed/timed out, continuing anyway for', deviceId, e);
						if (disablePrnOnTimeout) {
							console.warn('[DFU] disabling PRN waits after timeout for', deviceId);
							sessAfter.prn = 0;
						}
					}
					// reset counter
					sessAfter.packetsSincePrn = 0;
				}
			}
			offset = end;
			// 如果启用 nordic 模式，统计已发送字节
			const sess = this.sessions.get(deviceId);
			if (sess != null && typeof sess.bytesSent == 'number') {
				sess.bytesSent = (sess.bytesSent ?? 0) + slice.length;
			}
			// 简单节流与日志，避免过快。默认睡眠非常短以提高吞吐量; 可在设备上调节
			console.log('[DFU] wrote chunk for', deviceId, 'offset=', offset, '/', total, 'chunkSize=', slice.length, 'bytesSent=', sess != null ? sess.bytesSent : null, 'outstanding=', outstandingWrites);
			// emit upload progress event (percent) if available
			if (sess != null && typeof sess.bytesSent == 'number' && typeof sess.totalBytes == 'number') {
				const p = Math.floor((sess.bytesSent / sess.totalBytes) * 100);
				this._emitDfuEvent(deviceId, 'onProgress', p);
			}
			// yield to event loop and avoid starving the Android BLE stack
			await this._sleep(Math.max(0, writeSleepMs));
		}
	// wait for outstanding writes to drain before continuing with control commands
	if (outstandingWrites > 0) {
		const drainStart = Date.now();
		while (outstandingWrites > 0 && (Date.now() - drainStart) < drainOutstandingTimeout) {
			await this._sleep(Math.max(0, writeSleepMs));
		}
		if (outstandingWrites > 0) {
			console.warn('[DFU] outstandingWrites remain after drain timeout, continuing with', outstandingWrites);
		} else {
			console.log('[DFU] outstandingWrites drained before control phase');
		}
	}
	this._emitDfuEvent(deviceId, 'onUploadingCompleted', null);

			// force final throughput log before activate/validate
			_logThroughputIfNeeded(true);

		// 发送 activate/validate 命令到 control point（需根据设备协议实现）
		// 下面为占位：请替换为实际的 opcode
		// 在写入前先启动控制结果等待，防止设备快速响应导致丢失通知
		const controlTimeout = 20000;
		const controlResultPromise = this._waitForControlResult(deviceId, controlTimeout);
		try {
			// control writes: pass undefined options explicitly to satisfy the generator/typechecker
			const activatePayload = new Uint8Array([0x04]);
			console.log('[DFU] sending activate/validate payload=', Array.from(activatePayload));
			await serviceManager.writeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID, activatePayload, null);
			console.log('[DFU] activate/validate write returned for', deviceId);
		} catch (e) {
			// 写入失败时取消控制等待，避免悬挂定时器
			try {
				const sessOnWriteFail = this.sessions.get(deviceId);
				if (sessOnWriteFail != null && typeof sessOnWriteFail.reject == 'function') {
					sessOnWriteFail.reject(e);
				}
			} catch (rejectErr) { }
			await controlResultPromise.catch(() => { });
			try { await serviceManager.unsubscribeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID); } catch (e2) { }
			this.sessions.delete(deviceId);
			throw e;
		}
		console.log('[DFU] sent control activate/validate command to control point for', deviceId);
		this._emitDfuEvent(deviceId, 'onValidating', null);

	// 等待 control-point 返回最终结果（成功或失败），超时可配置
	console.log('[DFU] waiting for control result (timeout=', controlTimeout, ') for', deviceId);
	try {
		await controlResultPromise;
		console.log('[DFU] control result resolved for', deviceId);
	} catch (err) {
		// 清理订阅后抛出
		try { await serviceManager.unsubscribeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID); } catch (e) { }
		this.sessions.delete(deviceId);
		throw err;
	}

		// 取消订阅
		try {
			await serviceManager.unsubscribeCharacteristic(deviceId, DFU_SERVICE_UUID, DFU_CONTROL_POINT_UUID);
		} catch (e) { }
		console.log('[DFU] unsubscribed control point for', deviceId);

		// 清理会话
		this.sessions.delete(deviceId);
		console.log('[DFU] session cleared for', deviceId);

		return;
	}

	async _requestMtu(gatt : BluetoothGatt, mtu : number, timeoutMs : number) : Promise<void> {
		return new Promise<void>((resolve, reject) => {
			// 在当前项目，BluetoothGattCallback.onMtuChanged 未被封装；简单发起请求并等待短超时
			try {
				const ok = gatt.requestMtu(Math.floor(mtu) as Int);
				if (!ok) {
					return reject(new Error('requestMtu failed'));
				}
			} catch (e) {
				return reject(e);
			}
			// 无 callback 监听时退回，等待一小段时间以便成功
			setTimeout(() => resolve(), Math.min(2000, timeoutMs));
		});
	}

	_sleep(ms : number) {
		return new Promise<void>((r) => { setTimeout(() => { r() }, ms); });
	}

	_waitForPrn(deviceId : string, timeoutMs : number) : Promise<void> {
		const session = this.sessions.get(deviceId);
		if (session == null) return Promise.reject(new Error('no dfu session'));
		return new Promise<void>((resolve, reject) => {
			const timer = setTimeout(() => {
				// timeout waiting for PRN
				// clear pending handlers
				session.prnResolve = null;
				session.prnReject = null;
				reject(new Error('PRN timeout'));
			}, timeoutMs);
			const prnResolve = () => {
				clearTimeout(timer);
				resolve();
			};
			const prnReject = (err ?: any) => {
				clearTimeout(timer);
				reject(err);
			};
			session.prnResolve = prnResolve;
			session.prnReject = prnReject;
		});
	}

	// 默认 control point 解析器（非常通用的尝试解析：如果设备发送 progress byte 或成功码）
	_defaultControlParser(data : Uint8Array) : ControlParserResult | null {
		// 假设协议：第一个字节为 opcode, 第二字节可为状态或进度
		if (data == null || data.length === 0) return null;
		const op = data[0];
		// Nordic-style response: [0x10, requestOp, resultCode]
		if (op === 0x10 && data.length >= 3) {
			const requestOp = data[1];
			const resultCode = data[2];
			if (resultCode === 0x01) {
				return { type: 'success' };
			}
			return { type: 'error', error: { requestOp: requestOp, resultCode: resultCode, raw: Array.from(data) } };
		}
		// Nordic PRN notification: [0x11, LSB, MSB] -> return as progress (bytes received)
		if (op === 0x11 && data.length >= 3) {
			const lsb = data[1];
			const msb = data[2];
			const received = (msb << 8) | lsb;
			return { type: 'progress', progress: received };
		}
		// vendor-specific opcode example: 0x60 may mean 'response/progress' for some firmwares
		if (op === 0x60) {
			if (data.length >= 3) {
				const requestOp = data[1];
				const status = data[2];
				// Known success/status codes observed in field devices
				if (status === 0x00 || status === 0x01 || status === 0x0A) {
					return { type: 'success' };
				}
				return { type: 'error', error: { requestOp: requestOp, resultCode: status, raw: Array.from(data) } };
			}
			if (data.length >= 2) {
				return { type: 'progress', progress: data[1] };
			}
		}
		// 通用进度回退：若第二字节位于 0-100 之间，当作百分比
		if (data.length >= 2) {
			const maybeProgress = data[1];
			if (maybeProgress >= 0 && maybeProgress <= 100) {
				return { type: 'progress', progress: maybeProgress };
			}
		}
		// 若找到明显的 success opcode (示例 0x01) 或 error 0xFF
		if (op === 0x01) return { type: 'success' };
		if (op === 0xFF) return { type: 'error', error: data };
		return { type: 'info' };
	}

	// Nordic DFU control-parser（支持 Response and Packet Receipt Notification）
	_nordicControlParser(data : Uint8Array) : ControlParserResult | null {
		// Nordic opcodes (简化):
		// - 0x10 : Response (opcode, requestOp, resultCode)
		// - 0x11 : Packet Receipt Notification (opcode, value LSB, value MSB)
		if (data == null || data.length == 0) return null;
		const op = data[0];
		if (op == 0x11 && data.length >= 3) {
			// packet receipt notif: bytes received (little endian)
			const lsb = data[1];
			const msb = data[2];
			const received = (msb << 8) | lsb;
			// Return received bytes as progress value; parser does not resolve device-specific session here.
			return { type: 'progress', progress: received };
		}
		// Nordic vendor-specific progress/response opcode (example 0x60)
		if (op == 0x60) {
			if (data.length >= 3) {
				const requestOp = data[1];
				const status = data[2];
				if (status == 0x00 || status == 0x01 || status == 0x0A) {
					return { type: 'success' };
				}
				return { type: 'error', error: { requestOp, resultCode: status, raw: Array.from(data) } };
			}
			if (data.length >= 2) {
				return { type: 'progress', progress: data[1] };
			}
		}
		// Response: check result code for success (0x01 may indicate success in some stacks)
		if (op == 0x10 && data.length >= 3) {
			const requestOp = data[1];
			const resultCode = data[2];
			// Nordic resultCode 0x01 = SUCCESS typically
			if (resultCode == 0x01) return { type: 'success' };
			else return { type: 'error', error: { requestOp, resultCode } };
		}
		return null;
	}

	_handleControlNotification(deviceId : string, data : Uint8Array) {
		const session = this.sessions.get(deviceId);
		if (session == null) {
			console.warn('[DFU] control notification received but no session for', deviceId, 'data=', Array.from(data));
			return;
		}
		try {
			// human readable opcode mapping
			let opcodeName = 'unknown';
			switch (data[0]) {
				case 0x10: opcodeName = 'Response'; break;
				case 0x11: opcodeName = 'PRN'; break;
				case 0x60: opcodeName = 'VendorProgress'; break;
				case 0x01: opcodeName = 'SuccessOpcode'; break;
				case 0xFF: opcodeName = 'ErrorOpcode'; break;
			}
			console.log('[DFU] _handleControlNotification deviceId=', deviceId, 'opcode=0x' + data[0].toString(16), 'name=', opcodeName, 'raw=', Array.from(data));
			const parsed = session.controlParser != null ? session.controlParser(data) : null;
			if (session.onLog != null) session.onLog('DFU control notify: ' + Array.from(data).join(','));
			console.log('[DFU] parsed control result=', parsed);
			if (parsed == null) return;
			if (parsed.type == 'progress' && parsed.progress != null) {
				// 如果在 nordic 模式 parsed.progress 可能是已接收字节数，则转换为百分比
				if (session.useNordic == true && session.totalBytes != null && session.totalBytes > 0) {
						const percent = Math.floor((parsed.progress / session.totalBytes) * 100);
					session.onProgress?.(percent);
						// If we have written all bytes locally, log that event
						if (session.bytesSent != null && session.totalBytes != null && session.bytesSent >= session.totalBytes) {
							console.log('[DFU] all bytes written locally for', deviceId, 'bytesSent=', session.bytesSent, 'total=', session.totalBytes);
							// emit uploading completed once
							this._emitDfuEvent(deviceId, 'onUploadingCompleted', null);
						}
					// If a PRN wait is pending, resolve it (PRN indicates device received packets)
					if (typeof session.prnResolve == 'function') {
						try { session.prnResolve(); } catch (e) { }
						session.prnResolve = null;
						session.prnReject = null;
						session.packetsSincePrn = 0;
					}
				} else {
					const progress = parsed.progress
					if (progress != null) {
						console.log('[DFU] progress for', deviceId, 'progress=', progress);
						session.onProgress?.(progress);
						// also resolve PRN if was waiting (in case device reports numeric progress)
						if (typeof session.prnResolve == 'function') {
							try { session.prnResolve(); } catch (e) { }
							session.prnResolve = null;
							session.prnReject = null;
							session.packetsSincePrn = 0;
						}
					}
				}
			} else if (parsed.type == 'success') {
				console.log('[DFU] parsed success for', deviceId, 'resolving session');
				session.resolve();
				// Log final device-acknowledged success
				console.log('[DFU] device reported DFU success for', deviceId);
				this._emitDfuEvent(deviceId, 'onDfuCompleted', null);
			} else if (parsed.type == 'error') {
				console.error('[DFU] parsed error for', deviceId, parsed.error);
				session.reject(parsed.error ?? new Error('DFU device error'));
				this._emitDfuEvent(deviceId, 'onError', parsed.error ?? {});
			} else {
				// info - just log
			}
		} catch (e) {
			session.onLog?.('control parse error: ' + e);
			console.error('[DFU] control parse exception for', deviceId, e);
		}
	}

	_waitForControlResult(deviceId : string, timeoutMs : number) : Promise<void> {
		const session = this.sessions.get(deviceId);
		if (session == null) return Promise.reject(new Error('no dfu session'));
		return new Promise<void>((resolve, reject) => {
			// wrap resolve/reject to clear timer
			const timer = setTimeout(() => {
				// 超时
				console.error('[DFU] _waitForControlResult timeout for', deviceId);
				reject(new Error('DFU control timeout'));
			}, timeoutMs);
			const origResolve = () => {
				clearTimeout(timer);
				console.log('[DFU] _waitForControlResult resolved for', deviceId);
				resolve();
			};
			const origReject = (err ?: any) => {
				clearTimeout(timer);
				console.error('[DFU] _waitForControlResult rejected for', deviceId, 'err=', err);
				reject(err);
			};
			// replace session handlers temporarily (guard nullable)
			if (session != null) {
				session.resolve = origResolve;
				session.reject = origReject;
			}
		});
	}
}

export const dfuManager = new DfuManager();