/**
 * 打印机连接与下发：蓝牙(BLE) / 一体机(TCP localhost)
 */
import type { ActiveBtDeviceType, PrinterType } from './types/printer'
import classicBluetooth from './bluetoothTool.js'
import { getDeviceFingerprint } from '../deviceInfo'
import {
  blePairRequiresWriteNoResponse,
  isNordicUartStyleBleService,
  normalizeBleUuid,
} from './bleWriteModeRules'
import { getPrinterDriverByKey } from './manager/driverRegistry'
import { hasUserAcknowledgedBuiltinTsc } from './builtinTscCapabilityLog'
import {
  connectNativeFastPrinter,
  getNativeFastPrinterDebugInfo,
  isNativeFastPrinterAvailable,
  isNativeUposPrintSupported,
  isNativePrintCommandBytesSupported,
  printNativeCommandBytes,
  printNativeUposCommandBytes,
} from './nativeFastPrinter'
import { printRunDiag } from './printRunDiagnostics'

const STORAGE_PRINTER_TYPE = 'printerType'
const STORAGE_BT_DEVICE_ID = 'btDeviceId'
const STORAGE_BT_DEVICE_NAME = 'btDeviceName'
const STORAGE_BT_SERVICE_ID = 'btServiceId'
const STORAGE_BT_CHARACTERISTIC_ID = 'btCharacteristicId'
const STORAGE_BT_DEVICE_TYPE = 'btDeviceType' // 'ble' | 'classic'
const STORAGE_BT_TRANSPORT_MODE = 'btTransportMode' // 'native-plugin' | 'generic'
const STORAGE_BLE_MTU = 'bleMTU'
/** '1' = 仅支持 writeNoResponse 的特征，需在 writeBLECharacteristicValue 里指定 writeType */
const STORAGE_BLE_WRITE_NO_RESPONSE = 'bleWriteNoResponse'
const STORAGE_BUILTIN_PORT = 'builtinPort'
const STORAGE_PRINTER_DRIVER_KEY = 'printerDriverKey'
const STORAGE_UPOS_PREFER = 'uposPrefer' // 'builtin' | 'serial'
const STORAGE_UPOS_SERIAL_PATH = 'uposSerialPath'
const STORAGE_UPOS_BAUDRATE = 'uposBaudrate'
const STORAGE_UPOS_FORCE = 'uposForce' // '1' | '0'
const STORAGE_PRINTER_DEBUG_LOG = 'printerDebugLog' // '1' | '0'

const BUILTIN_PROBE_PORTS = [9100, 4000, 9000, 6000]
const BUILTIN_PRINTER_DEVICE_KEYWORDS: string[] = [
  // 在这里补充需要走 Built-in 的设备型号关键字（小写匹配）
  // 例如：'desktop-aio', 'pos-terminal-x1'
  'rk3568',
  'aoa_rk3568',
]
export type BtDeviceType = ActiveBtDeviceType

export const PrinterStorageKeys = {
  type: STORAGE_PRINTER_TYPE,
  btDeviceId: STORAGE_BT_DEVICE_ID,
  btDeviceName: STORAGE_BT_DEVICE_NAME,
  btServiceId: STORAGE_BT_SERVICE_ID,
  btCharacteristicId: STORAGE_BT_CHARACTERISTIC_ID,
  btDeviceType: STORAGE_BT_DEVICE_TYPE,
  btTransportMode: STORAGE_BT_TRANSPORT_MODE,
  bleMTU: STORAGE_BLE_MTU,
  bleWriteNoResponse: STORAGE_BLE_WRITE_NO_RESPONSE,
  driverKey: STORAGE_PRINTER_DRIVER_KEY,
  uposPrefer: STORAGE_UPOS_PREFER,
  uposSerialPath: STORAGE_UPOS_SERIAL_PATH,
  uposBaudrate: STORAGE_UPOS_BAUDRATE,
  uposForce: STORAGE_UPOS_FORCE,
  debugLog: STORAGE_PRINTER_DEBUG_LOG,
} as const

export function setPrinterType (type: PrinterType) {
  uni.setStorageSync(STORAGE_PRINTER_TYPE, type)
}

export function setBluetoothConnection (info: {
  deviceId: string
  deviceName: string
  serviceId?: string
  characteristicId?: string
  deviceType?: BtDeviceType
  transportMode?: 'native-plugin' | 'generic'
  mtu?: number
  driverKey?: string
  /** 当前特征是否必须走 writeNoResponse（仅 write 为 false 时） */
  bleWriteUsesNoResponse?: boolean
}) {
  uni.setStorageSync(STORAGE_PRINTER_TYPE, 'bluetooth')
  uni.setStorageSync(STORAGE_BT_DEVICE_ID, info.deviceId)
  uni.setStorageSync(STORAGE_BT_DEVICE_NAME, info.deviceName)
  uni.setStorageSync(STORAGE_BT_SERVICE_ID, info.serviceId || '')
  uni.setStorageSync(STORAGE_BT_CHARACTERISTIC_ID, info.characteristicId || '')
  uni.setStorageSync(STORAGE_BT_DEVICE_TYPE, info.deviceType || 'ble')
  uni.setStorageSync(
    STORAGE_BT_TRANSPORT_MODE,
    info.transportMode || (info.deviceType === 'classic' ? 'generic' : 'generic')
  )
  uni.setStorageSync(STORAGE_BLE_MTU, info.mtu != null ? info.mtu : BLE_MTU_DEFAULT)
  uni.setStorageSync(STORAGE_PRINTER_DRIVER_KEY, info.driverKey || '')
  if (info.deviceType === 'ble' || !info.deviceType) {
    uni.setStorageSync(STORAGE_BLE_WRITE_NO_RESPONSE, info.bleWriteUsesNoResponse ? '1' : '0')
  } else {
    uni.setStorageSync(STORAGE_BLE_WRITE_NO_RESPONSE, '0')
  }
}

export function setBuiltinPrinter (driverKey = 'generic-tsc') {
  uni.setStorageSync(STORAGE_PRINTER_TYPE, 'builtin')
  uni.setStorageSync(STORAGE_PRINTER_DRIVER_KEY, driverKey)
}

export function clearPrinter () {
  uni.removeStorageSync(STORAGE_PRINTER_TYPE)
  uni.removeStorageSync(STORAGE_BT_DEVICE_ID)
  uni.removeStorageSync(STORAGE_BT_DEVICE_NAME)
  uni.removeStorageSync(STORAGE_BT_SERVICE_ID)
  uni.removeStorageSync(STORAGE_BT_CHARACTERISTIC_ID)
  uni.removeStorageSync(STORAGE_BT_DEVICE_TYPE)
  uni.removeStorageSync(STORAGE_BT_TRANSPORT_MODE)
  uni.removeStorageSync(STORAGE_BLE_MTU)
  uni.removeStorageSync(STORAGE_BLE_WRITE_NO_RESPONSE)
  uni.removeStorageSync(STORAGE_BUILTIN_PORT)
  uni.removeStorageSync(STORAGE_PRINTER_DRIVER_KEY)
  uni.removeStorageSync(STORAGE_UPOS_PREFER)
  uni.removeStorageSync(STORAGE_UPOS_SERIAL_PATH)
  uni.removeStorageSync(STORAGE_UPOS_BAUDRATE)
  uni.removeStorageSync(STORAGE_UPOS_FORCE)
  uni.removeStorageSync(STORAGE_PRINTER_DEBUG_LOG)
}

export function setUposOptions (options: {
  prefer?: 'builtin' | 'serial'
  serialPath?: string
  baudrate?: number
  /** 强制尝试 UPOS（不依赖机型关键字）；用于新机型接入/排查 */
  force?: boolean
}) {
  if (options.prefer) uni.setStorageSync(STORAGE_UPOS_PREFER, options.prefer)
  if (options.serialPath != null) uni.setStorageSync(STORAGE_UPOS_SERIAL_PATH, String(options.serialPath || ''))
  if (options.baudrate != null) uni.setStorageSync(STORAGE_UPOS_BAUDRATE, String(Math.max(1200, Math.floor(options.baudrate || 9600))))
  if (typeof options.force === 'boolean') uni.setStorageSync(STORAGE_UPOS_FORCE, options.force ? '1' : '0')
}

/** 供 printerManager / native 模板 UPOS 下发读取（与内置打印页 UPOS 选项同源） */
export function getStoredUposPrintOptions (): {
  prefer: 'builtin' | 'serial'
  serialPath?: string
  baudrate: number
  force: boolean
} {
  const preferRaw = String(uni.getStorageSync(STORAGE_UPOS_PREFER) || '').toLowerCase()
  const prefer = (preferRaw === 'serial' ? 'serial' : 'builtin') as 'builtin' | 'serial'
  const serialPath = String(uni.getStorageSync(STORAGE_UPOS_SERIAL_PATH) || '').trim()
  const baudrate = Math.max(1200, parseInt(String(uni.getStorageSync(STORAGE_UPOS_BAUDRATE) || '9600')) || 9600)
  const force = uni.getStorageSync(STORAGE_UPOS_FORCE) === '1'
  return {
    prefer,
    // 避免 “prefer=builtin 但仍携带串口路径” 造成 preflight/排查误导
    serialPath: (prefer === 'serial' && serialPath) ? serialPath : undefined,
    baudrate,
    force,
  }
}

function getUposOptionsFromStorage () {
  return getStoredUposPrintOptions()
}

export function setPrinterDebugLogEnabled (enabled: boolean) {
  uni.setStorageSync(STORAGE_PRINTER_DEBUG_LOG, enabled ? '1' : '0')
}

export function isPrinterDebugLogEnabled (): boolean {
  return uni.getStorageSync(STORAGE_PRINTER_DEBUG_LOG) === '1'
}

type PrinterDebugSnapshot = {
  when: number
  reason: string
  printerType: PrinterType | ''
  driverKey: string
  dataBytes?: number
  deviceFingerprint: string
  availableTypes: PrinterType[]
  bluetoothConnection: ReturnType<typeof getBluetoothConnection>
  builtin: {
    uposSupported: boolean
    uposOptions: ReturnType<typeof getStoredUposPrintOptions>
    keywordMatched: boolean
    uposWillTry: boolean
    tcpPluginAvailable: boolean
    savedPort: number
  }
  nativeFastPrinter: any
  /** 用户在蓝牙页是否已确认内置 TSC/TSPL（无法自动检测机芯） */
  builtinTscUserAcknowledged: boolean
}

export async function getPrinterDebugSnapshot (options?: {
  reason?: string
  dataBytes?: number
}): Promise<PrinterDebugSnapshot> {
  const reason = String(options?.reason || 'debug')
  const printerType = getPrinterType()
  const driverKey = getCurrentPrinterDriverKey()
  const deviceFingerprint = getDeviceFingerprint()
  const availableTypes = getAvailablePrinterTypes()
  const bluetoothConnection = getBluetoothConnection()

  const uposOptions = getUposOptionsFromStorage()
  const keywordMatched = !!deviceFingerprint
    && (deviceFingerprint.includes('rk3568') || deviceFingerprint.includes('aoa_rk3568'))
  const uposSupported = isNativeUposPrintSupported()
  const uposWillTry = uposSupported && (uposOptions.force || keywordMatched)

  let tcpPluginAvailable = false
  try {
    const u = uni as any
    tcpPluginAvailable = !!(u?.requireNativePlugin && u.requireNativePlugin('moe-tcp-client'))
  } catch (_) {
    tcpPluginAvailable = false
  }

  const savedPort = parseInt(String(uni.getStorageSync(STORAGE_BUILTIN_PORT) || '0')) || 0

  let nativeFastPrinter: any = null
  try {
    nativeFastPrinter = await getNativeFastPrinterDebugInfo()
  } catch (e: any) {
    nativeFastPrinter = { error: e?.message || String(e || 'getDebugInfo failed') }
  }

  return {
    when: Date.now(),
    reason,
    printerType,
    driverKey,
    dataBytes: options?.dataBytes,
    deviceFingerprint,
    availableTypes,
    bluetoothConnection,
    builtin: {
      uposSupported,
      uposOptions,
      keywordMatched,
      uposWillTry,
      tcpPluginAvailable,
      savedPort,
    },
    nativeFastPrinter,
    builtinTscUserAcknowledged: hasUserAcknowledgedBuiltinTsc(),
  }
}

export async function logPrinterDebug (options?: {
  reason?: string
  dataBytes?: number
}): Promise<void> {
  if (!isPrinterDebugLogEnabled()) return
  const snapshot = await getPrinterDebugSnapshot(options)
  try {
    console.log('[printer-debug] snapshot:', snapshot)
  } catch (_) {}
}

const BLE_MTU_DEFAULT = 20

export function getPrinterType (): PrinterType | '' {
  const type = (uni.getStorageSync(STORAGE_PRINTER_TYPE) as PrinterType) || ''
  if (!type) return ''
  if (getAvailablePrinterTypes().includes(type)) return type
  clearPrinter()
  return ''
}

export function getCurrentPrinterDriverKey (): string {
  return String(uni.getStorageSync(STORAGE_PRINTER_DRIVER_KEY) || '')
}

export function getBluetoothConnection (): {
  deviceId: string
  deviceName: string
  serviceId: string
  characteristicId: string
  deviceType: BtDeviceType
  transportMode: 'native-plugin' | 'generic'
  mtu: number
  bleWriteUsesNoResponse: boolean
} | null {
  const deviceId = uni.getStorageSync(STORAGE_BT_DEVICE_ID)
  const deviceType = (uni.getStorageSync(STORAGE_BT_DEVICE_TYPE) as BtDeviceType) || 'ble'
  const transportMode = (uni.getStorageSync(STORAGE_BT_TRANSPORT_MODE) as 'native-plugin' | 'generic') || 'generic'
  if (!deviceId) return null
  if (deviceType === 'classic') {
    /**
     * 必须原样返回 STORAGE_BT_TRANSPORT_MODE（即上面的 transportMode）。
     * 此前误把 native-plugin 读时改回 generic，导致「永远不走安卓基座 / printCommandBytes」，
     * 一体机只能走 JS 经典蓝牙，极慢且易卡在 31% 等进度。
     */
    return {
      deviceId,
      deviceName: uni.getStorageSync(STORAGE_BT_DEVICE_NAME) || 'Printer',
      serviceId: '',
      characteristicId: '',
      deviceType: 'classic',
      transportMode,
      mtu: Number(uni.getStorageSync(STORAGE_BLE_MTU)) || BLE_MTU_DEFAULT,
      bleWriteUsesNoResponse: false,
    }
  }
  const serviceId = uni.getStorageSync(STORAGE_BT_SERVICE_ID)
  const characteristicId = uni.getStorageSync(STORAGE_BT_CHARACTERISTIC_ID)
  if (!serviceId || !characteristicId) return null
  return {
    deviceId,
    deviceName: uni.getStorageSync(STORAGE_BT_DEVICE_NAME) || 'Printer',
    serviceId,
    characteristicId,
    deviceType: 'ble',
    transportMode,
    mtu: Number(uni.getStorageSync(STORAGE_BLE_MTU)) || BLE_MTU_DEFAULT,
    bleWriteUsesNoResponse: uni.getStorageSync(STORAGE_BLE_WRITE_NO_RESPONSE) === '1',
  }
}

/**
 * 经典蓝牙且当前为 generic 时，在插件与 printCommandBytes 可用时尝试 connectNativeFastPrinter 并写入 native-plugin，
 * 避免仍显示已连蓝牙但实际全程 JS 分包下发（极慢、易卡进度）。
 */
export async function ensureNativeClassicTransportIfPossible (): Promise<boolean> {
  const conn = getBluetoothConnection()
  if (!conn || conn.deviceType !== 'classic') return false
  if (conn.transportMode === 'native-plugin') return true
  if (!isNativeFastPrinterAvailable() || !isNativePrintCommandBytesSupported()) return false
  const driverKey = getCurrentPrinterDriverKey()
  const name = String(conn.deviceName || '').toLowerCase()
  const preferNative =
    driverKey === 'd320fax' ||
    name.includes('virtual bt') ||
    name.includes('gprinter') ||
    name.includes('d320')
  if (!preferNative) return false
  try {
    await connectNativeFastPrinter({
      deviceId: conn.deviceId,
      deviceName: conn.deviceName || '',
    })
    setBluetoothConnection({
      deviceId: conn.deviceId,
      deviceName: conn.deviceName,
      serviceId: conn.serviceId,
      characteristicId: conn.characteristicId,
      deviceType: 'classic',
      transportMode: 'native-plugin',
      mtu: conn.mtu,
      driverKey: getCurrentPrinterDriverKey(),
    })
    return true
  } catch (e) {
    console.warn('[printer] ensureNativeClassicTransportIfPossible failed', e)
    return false
  }
}

/**
 * 经典蓝牙已走 native-fast-printer 基座链路（常见：一体机「Virtual BT Printer」/ 佳博 SDK）。
 * 预览与打印日志重打在此模式下应走原生 printTemplate；否则走 BLE 或 JS 经典蓝牙光栅/直发 TSC。
 */
export function isNativeBaseClassicBluetoothTransport (): boolean {
  const conn = getBluetoothConnection()
  return conn?.deviceType === 'classic' && conn?.transportMode === 'native-plugin'
}

export function isBuiltinConnected (): boolean {
  return getPrinterType() === 'builtin'
}

export function isBuiltinPrinterAvailable (): boolean {
  // #ifdef APP-PLUS
  try {
    const plugin = (uni as any)?.requireNativePlugin
      ? (uni as any).requireNativePlugin('moe-tcp-client')
      : null
    return !!plugin
  } catch (_) {
    return false
  }
  // #endif
  // #ifndef APP-PLUS
  return false
  // #endif
}

export function isBuiltinPrinterEnabledByDeviceModel (): boolean {
  const fingerprint = getDeviceFingerprint()
  if (!fingerprint) return false
  return BUILTIN_PRINTER_DEVICE_KEYWORDS.some(keyword => fingerprint.includes(String(keyword || '').toLowerCase()))
}

export function getAvailablePrinterTypes (): PrinterType[] {
  if (isBuiltinPrinterAvailable() && isBuiltinPrinterEnabledByDeviceModel()) {
    // AIO 机型同时保留蓝牙入口，避免只能走内置打印导致无法连接 Virtual BT Printer。
    return ['bluetooth', 'builtin']
  }
  return ['bluetooth']
}

function buildClassicBluetoothError (message: string, deviceId?: string): Error {
  const baseMessage = String(message || 'Classic Bluetooth error')
  if (!classicBluetooth || typeof classicBluetooth.getDebugState !== 'function') {
    return new Error(baseMessage)
  }
  try {
    const debugState = classicBluetooth.getDebugState() || {}
    const details: string[] = []
    if (deviceId) details.push(`device=${deviceId}`)
    if (debugState.lastSocketStrategy) details.push(`socket=${debugState.lastSocketStrategy}`)
    if (debugState.connectionState) details.push(`state=${debugState.connectionState}`)
    if (typeof debugState.socketConnected === 'boolean') details.push(`connected=${debugState.socketConnected}`)
    if (typeof debugState.outputReady === 'boolean') details.push(`outputReady=${debugState.outputReady}`)
    if (debugState.lastSendMode) details.push(`sendMode=${debugState.lastSendMode}`)
    if (debugState.lastSendError) details.push(`sendError=${debugState.lastSendError}`)
    else if (debugState.lastError) details.push(`lastError=${debugState.lastError}`)
    if (details.length === 0) return new Error(baseMessage)
    return new Error(`${baseMessage}\n${details.join('\n')}`)
  } catch (_) {
    return new Error(baseMessage)
  }
}

/**
 * 发送打印数据到当前已选打印机
 * @param data 字节数组（TSC 指令）
 * @param onProgress 可选进度回调 0~100
 */
export function sendToPrinter (
  data: number[],
  onProgress?: (percent: number) => void
): Promise<void> {
  void logPrinterDebug({ reason: 'sendToPrinter', dataBytes: data?.length || 0 })
  const type = getPrinterType()
  printRunDiag('sendToPrinter', { type, dataBytes: data?.length || 0 })
  if (type === 'bluetooth') {
    const conn = getBluetoothConnection()
    if (conn && conn.deviceType === 'classic') {
      if (conn.transportMode === 'native-plugin' && isNativePrintCommandBytesSupported()) {
        return sendViaNativeClassicPlugin(data, onProgress).catch((err) => {
          console.warn('[printer] native printCommandBytes failed, fallback JS classic', err)
          return sendViaClassic(data, onProgress)
        })
      }
      return sendViaClassic(data, onProgress)
    }
    return sendViaBle(data, onProgress)
  }
  if (type === 'builtin') {
    return sendViaBuiltin(data)
  }
  return Promise.reject(new Error('No printer connected. Please connect a Bluetooth or built-in printer first.'))
}

/** 与打印机页扫描/连接一致：未 open 适配器时 writeBLECharacteristicValue 报 fail not init */
function bleOpenAdapter (): Promise<void> {
  return new Promise((resolve, reject) => {
    // #ifdef APP-PLUS
    uni.openBluetoothAdapter({
      success: () => resolve(),
      fail: (err: any) => {
        const msg = String(err?.errMsg || '')
        const code = err?.errCode
        if (msg.includes('already') || code === 10001) resolve()
        else reject(new Error(msg || 'openBluetoothAdapter failed'))
      },
    })
    // #endif
    // #ifndef APP-PLUS
    resolve()
    // #endif
  })
}

/** 设置页 onUnmounted 可能已 closeBluetoothAdapter，需重新建链后才能写特征值 */
function bleEnsureDeviceConnected (deviceId: string): Promise<void> {
  return new Promise((resolve, reject) => {
    // #ifdef APP-PLUS
    uni.createBLEConnection({
      deviceId,
      timeout: 15000,
      success: () => resolve(),
      fail: (err: any) => {
        const msg = String(err?.errMsg || '')
        const code = err?.errCode
        if (
          code === -1 ||
          msg.includes('already') ||
          msg.includes('Connected') ||
          msg.includes('connected') ||
          msg.includes('已连接')
        ) {
          resolve()
          return
        }
        reject(new Error(msg || 'createBLEConnection failed'))
      },
    })
    // #endif
    // #ifndef APP-PLUS
    resolve()
    // #endif
  })
}

/**
 * 每次打印前会 createBLEConnection，链路 MTU 可能回到默认 23；若仍按 storage 里 512 分包，实机常丢数据但 write 仍 success。
 */
let bleNordicUartValueListenerAttached = false

function attachBleNordicUartValueListener (): void {
  if (bleNordicUartValueListenerAttached) return
  bleNordicUartValueListenerAttached = true
  try {
    if (typeof uni.onBLECharacteristicValueChange === 'function') {
      uni.onBLECharacteristicValueChange(() => {})
    }
  } catch (_) {}
}

/**
 * Nordic UART 类标签机：未对 TX 打开 notify 时，部分安卓栈第二包起对 RX 写会统一报 property not support (10007)。
 * 连接后、大批量 write 前各调用一次（幂等）。
 */
export function ensureBleUartNotifyIfNeeded (
  deviceId: string,
  serviceId: string,
  rxCharacteristicId?: string
): Promise<void> {
  // #ifndef APP-PLUS
  return Promise.resolve()
  // #endif
  // #ifdef APP-PLUS
  if (!isNordicUartStyleBleService(serviceId)) {
    return Promise.resolve()
  }
  const rx = normalizeBleUuid(rxCharacteristicId || '')
  return new Promise((resolve) => {
    uni.getBLEDeviceCharacteristics({
      deviceId,
      serviceId,
      success: (res) => {
        const chars = ((res as any).characteristics || []) as Array<{ uuid?: string; properties?: Record<string, unknown> }>
        const notifyChar = chars.find((c) => {
          const p = c.properties || {}
          const n =
            p.notify === true ||
            p.notify === 'true' ||
            p.indicate === true ||
            p.indicate === 'true'
          if (!n) return false
          const cid = normalizeBleUuid(String(c.uuid || ''))
          if (rx && cid === rx) return false
          return true
        })
        if (!notifyChar?.uuid) {
          console.warn('[BLE] Nordic 串口：未找到可订阅的 notify/indicate 特征，跳过后续写入可能仍 10007')
          resolve()
          return
        }
        const cid = String(notifyChar.uuid)
        uni.notifyBLECharacteristicValueChange({
          deviceId,
          serviceId,
          characteristicId: cid,
          state: true,
          success: () => {
            attachBleNordicUartValueListener()
            console.log('[BLE] Nordic 串口已订阅 notify:', cid)
            setTimeout(() => resolve(), 80)
          },
          fail: () => {
            resolve()
          },
        })
      },
      fail: () => resolve(),
    })
  })
  // #endif
}

function requestBleMtuNegotiation (deviceId: string, preferredMtu: number): Promise<number> {
  return new Promise((resolve) => {
    // #ifdef APP-PLUS
    const targetMtu = Math.max(20, Math.min(512, Math.round(preferredMtu || 20)))
    if (targetMtu <= 20 || typeof (uni as any).setBLEMTU !== 'function') {
      resolve(20)
      return
    }
    let settled = false
    const done = (value: number) => {
      if (settled) return
      settled = true
      clearTimeout(timer)
      const m = Math.max(20, Math.round(value || 20))
      try {
        uni.setStorageSync(STORAGE_BLE_MTU, m)
      } catch (_) {}
      resolve(m)
    }
    const timer = setTimeout(() => done(20), 3000)
    ;(uni as any).setBLEMTU({
      deviceId,
      mtu: targetMtu,
      success: (res: any) => done(Number(res?.mtu) || targetMtu),
      fail: () => done(20),
    })
    // #endif
    // #ifndef APP-PLUS
    resolve(20)
    // #endif
  })
}

function sendViaBle (
  data: number[],
  onProgress?: (percent: number) => void
): Promise<void> {
  const conn = getBluetoothConnection()
  if (!conn) {
    return Promise.reject(new Error('Bluetooth printer not connected.'))
  }
  const { deviceId, serviceId, characteristicId, bleWriteUsesNoResponse } = conn

  const runWritesWithPayloadSize = (payloadSize: number): Promise<void> => {
    const chunks: number[][] = []
    for (let i = 0; i < data.length; i += payloadSize) {
      chunks.push(data.slice(i, i + payloadSize))
    }
    const total = chunks.length
    let sent = 0
    let completed = false
    let timeoutId: ReturnType<typeof setTimeout> | null = setTimeout(() => {}, 0)
    /** Nordic 大包连续 0ms 间隔时，部分机型第二包起 10007；与 enable notify 配合 */
    const nordicUart = isNordicUartStyleBleService(serviceId)
    const writeDelayMs =
      nordicUart && payloadSize >= 64
        ? 18
        : payloadSize >= 180
          ? 0
          : payloadSize > 20
            ? 2
            : 10

    /** Nordic 白名单：仅用于失败时是否禁止翻到带响应写（佳博等）；写入方式以连接时写入 storage 的 bleWriteUsesNoResponse 为准 */
    const blePairForceNoResponse = blePairRequiresWriteNoResponse(serviceId, characteristicId)

    /** 本 job 内若因 property not support 翻过模式，后续包统一用 effectiveUseNoResp */
    let effectiveUseNoResp = bleWriteUsesNoResponse
    let hasFlippedWriteModeThisJob = false
    let pendingPersistUseNoResp: boolean | null = null

    const resetTimeout = (reject: (reason?: any) => void) => {
      if (timeoutId) clearTimeout(timeoutId)
      timeoutId = setTimeout(() => {
        if (completed) return
        completed = true
        reject(new Error('BLE write timeout'))
      }, Math.max(60000, total * 500))
    }

    function logBleWriteFail (err: any, useNoResp: boolean, bufferLen: number) {
      const msg = String(err?.errMsg ?? err?.message ?? '')
      let errSerialized = ''
      try {
        errSerialized = JSON.stringify(err)
      } catch {
        errSerialized = String(err)
      }
      console.error('[sendViaBle] writeBLECharacteristicValue fail — 完整信息供真机调试复制', {
        errMsg: msg,
        errCode: err?.errCode,
        errno: err?.errno,
        code: err?.code,
        writeTypeUsed: useNoResp ? 'writeNoResponse' : '(omitted, default write)',
        effectiveUseNoResp,
        bleWriteUsesNoResponseSaved: bleWriteUsesNoResponse,
        bufferLen,
        sentIndex: sent,
        totalChunks: total,
        serviceId,
        characteristicId,
        deviceId,
        rawErr: err,
        errSerialized,
        blePairForcedNoResponse: blePairForceNoResponse,
      })
    }

    function writeOneBuffer (buffer: ArrayBuffer): Promise<void> {
      return new Promise((resolve, reject) => {
        const tryWrite = (useNoResp: boolean, allowFlip: boolean) => {
          const opts: UniApp.WriteBLECharacteristicValueOption = {
            deviceId,
            serviceId,
            characteristicId,
            value: buffer,
          }
          /** 仅无响应写显式声明；带响应写不传 writeType，与 uni 历史默认一致，避免部分机型报 property not support */
          if (useNoResp) {
            opts.writeType = 'writeNoResponse'
          }
          uni.writeBLECharacteristicValue({
            ...opts,
            success: () => {
              if (pendingPersistUseNoResp != null) {
                try {
                  uni.setStorageSync(
                    PrinterStorageKeys.bleWriteNoResponse,
                    pendingPersistUseNoResp ? '1' : '0'
                  )
                } catch (_) {}
                pendingPersistUseNoResp = null
              }
              resolve()
            },
            fail: (err: any) => {
              const msg = String(err?.errMsg ?? err?.message ?? '')
              logBleWriteFail(err, useNoResp, buffer.byteLength)
              const notSupport =
                msg.includes('property not support') ||
                msg.includes('not support') ||
                String(err?.errCode) === '10007'
              if (allowFlip && !hasFlippedWriteModeThisJob && notSupport) {
                const nextUseNoResp = !useNoResp
                /**
                 * 佳博等 Nordic 串口：GATT 虽声明 write，实测只接受 writeNoResponse。
                 * 若 writeNoResponse 偶发失败后翻到「默认写」，首包可能仍 success，从第二包起必现 10007（打印量变长更易触发）。
                 */
                if (blePairForceNoResponse && !nextUseNoResp) {
                  console.warn(
                    '[sendViaBle] 白名单串口禁止切到带响应写；请保持 writeNoResponse 或检查连接/MTU'
                  )
                  reject(new Error(msg || 'BLE write failed'))
                  return
                }
                hasFlippedWriteModeThisJob = true
                effectiveUseNoResp = nextUseNoResp
                pendingPersistUseNoResp = effectiveUseNoResp
                console.warn('[sendViaBle] property not support → 切换写入方式重试本包', {
                  nextMode: effectiveUseNoResp ? 'writeNoResponse' : 'defaultWrite(no writeType)',
                })
                tryWrite(effectiveUseNoResp, false)
                return
              }
              reject(new Error(msg || 'BLE write failed'))
            },
          })
        }
        tryWrite(effectiveUseNoResp, !hasFlippedWriteModeThisJob)
      })
    }

    function sendNext (): Promise<void> {
      if (completed) {
        return Promise.reject(new Error('BLE write timeout'))
      }
      if (sent >= total) {
        completed = true
        if (timeoutId) clearTimeout(timeoutId)
        /** 末包 write 成功后立刻 resolve 时，部分机芯尚未吃完缓冲；短延迟再结束，减少「界面成功但不出纸」 */
        const settleMs = data.length > 400 ? 180 : 50
        return new Promise<void>((resolve) => {
          setTimeout(() => {
            if (onProgress) onProgress(100)
            resolve()
          }, settleMs)
        })
      }
      const chunk = chunks[sent]
      const buffer = new ArrayBuffer(chunk.length)
      const view = new DataView(buffer)
      for (let j = 0; j < chunk.length; j++) {
        view.setUint8(j, chunk[j] & 0xff)
      }
      return new Promise((resolve, reject) => {
        resetTimeout(reject)
        writeOneBuffer(buffer)
          .then(() => {
            if (completed) return
            sent++
            if (onProgress) onProgress(Math.round((sent / total) * 100))
            if (writeDelayMs <= 0) {
              sendNext().then(resolve).catch(reject)
              return
            }
            setTimeout(() => sendNext().then(resolve).catch(reject), writeDelayMs)
          })
          .catch((e: any) => {
            if (completed) return
            completed = true
            if (timeoutId) clearTimeout(timeoutId)
            reject(e instanceof Error ? e : new Error(String(e?.message || e || 'BLE write failed')))
          })
      })
    }

    return sendNext()
  }

  /**
   * 单包 ATT 可写字节数：理论为 mtu-3；MTU≤23 时旧代码误用 mtu 本值（如 23）会超过链路真上限 20，导致截断/无出纸却 write success。
   * 协商到 512 时不少佳博/安卓组合仍不能稳定传 500+ 字节/包，需再压到安全上限。
   */
  const mtuToPayloadSize = (negotiatedMtu: number) => {
    const mtu = Math.max(23, Math.min(512, Math.round(negotiatedMtu || 23)))
    const attPayload = Math.max(20, mtu - 3)
    const SAFE_BLE_WRITE_CAP = 182
    return Math.min(attPayload, SAFE_BLE_WRITE_CAP)
  }

  // #ifdef APP-PLUS
  if (conn.deviceType === 'ble') {
    const driver = getPrinterDriverByKey(getCurrentPrinterDriverKey())
    const preferred = driver.preferredBleMtu || BLE_MTU_DEFAULT
    return bleOpenAdapter()
      .then(() => bleEnsureDeviceConnected(deviceId))
      .then(() => new Promise<void>((r) => setTimeout(r, 100)))
      .then(() => ensureBleUartNotifyIfNeeded(deviceId, serviceId, characteristicId))
      .then(() => requestBleMtuNegotiation(deviceId, preferred))
      .then((negotiated) => runWritesWithPayloadSize(mtuToPayloadSize(negotiated)))
  }
  // #endif
  return runWritesWithPayloadSize(mtuToPayloadSize(conn.mtu || BLE_MTU_DEFAULT))
}

/** 大包/虚拟蓝牙写入慢：按字节量拉长等待，避免 JS 已超时拒绝但底层仍在写出（纸已出、接口 9 未落库） */
export function estimateClassicSendTimeoutMs (byteLength: number): number {
  const n = Math.max(0, Math.floor(byteLength || 0))
  const base = 90000
  const perByte = Math.floor(n / 400)
  return Math.min(600000, Math.max(60000, base + perByte))
}

function numberArrayToBase64 (data: number[]): string {
  const u8 = new Uint8Array(data.length)
  for (let i = 0; i < data.length; i++) u8[i] = data[i] & 0xff
  try {
    const u = uni as any
    if (typeof u.arrayBufferToBase64 === 'function') {
      return u.arrayBufferToBase64(u8.buffer)
    }
  } catch (_) {}
  let binary = ''
  for (let i = 0; i < u8.length; i++) binary += String.fromCharCode(u8[i])
  if (typeof btoa !== 'undefined') return btoa(binary)
  return ''
}

/**
 * 经典蓝牙已走 native-fast-printer 佳博 SDK 时，整页光栅字节经 printCommandBytes 下发，避免 JS 蓝牙慢发。
 */
function sendViaNativeClassicPlugin (
  data: number[],
  onProgress?: (percent: number) => void
): Promise<void> {
  const conn = getBluetoothConnection()
  if (!conn || conn.deviceType !== 'classic' || conn.transportMode !== 'native-plugin') {
    return Promise.reject(new Error('NATIVE_CLASSIC_TRANSPORT_NOT_ACTIVE'))
  }
  if (!isNativePrintCommandBytesSupported()) {
    return Promise.reject(new Error('NATIVE_PRINT_COMMAND_BYTES_NOT_SUPPORTED'))
  }
  const base64 = numberArrayToBase64(data)
  if (!base64) {
    return Promise.reject(new Error('BASE64_ENCODE_FAILED'))
  }
  if (onProgress) onProgress(5)
  return printNativeCommandBytes({
    deviceId: conn.deviceId,
    deviceName: conn.deviceName,
    base64,
  }).then(() => {
    if (onProgress) onProgress(100)
  })
}

function sendViaClassic (
  data: number[],
  onProgress?: (percent: number) => void
): Promise<void> {
  // #ifdef APP-PLUS
  const conn = getBluetoothConnection()
  if (!conn || conn.deviceType !== 'classic') {
    return Promise.reject(new Error('Classic Bluetooth printer not connected.'))
  }
  const sendData = data.map((byte) => {
    const value = byte & 0xff
    return value >= 128 ? value - 256 : value
  })
  const sendTimeoutMs = estimateClassicSendTimeoutMs(sendData.length)
  return new Promise((resolve, reject) => {
    let settled = false
    const finish = (fn: () => void) => {
      if (settled) return
      settled = true
      clearTimeout(timeoutId)
      fn()
    }
    const timeoutId = setTimeout(() => {
      finish(() => {
        reject(buildClassicBluetoothError('Classic Bluetooth send timeout', conn.deviceId))
      })
    }, sendTimeoutMs + 25000)

    try {
      if (!classicBluetooth) {
        finish(() => reject(new Error('Classic Bluetooth not available')))
        return
      }
      const isReady = () => {
        const debugState = typeof classicBluetooth.getDebugState === 'function'
          ? classicBluetooth.getDebugState()
          : null
        const connectionState = String(debugState?.connectionState || '').trim().toLowerCase()
        const ready = debugState
          ? (!!debugState.outputReady && (!!debugState.socketConnected || connectionState === 'connected'))
          : true
        return { ready, debugState }
      }

      const sendNow = () => {
        if (typeof classicBluetooth.sendByteDataAsync === 'function') {
          let callbackSettled = false
          const asyncTimeoutTimer = setTimeout(() => {
            if (callbackSettled) return
            callbackSettled = true
            finish(() => reject(buildClassicBluetoothError('Classic Bluetooth async send timeout', conn.deviceId)))
          }, sendTimeoutMs)
          const started = classicBluetooth.sendByteDataAsync(
            sendData,
            (ok: boolean, errorMessage?: string) => {
              callbackSettled = true
              clearTimeout(asyncTimeoutTimer)
              finish(() => {
                if (onProgress) onProgress(100)
                if (ok) {
                  resolve()
                  return
                }
                reject(buildClassicBluetoothError(
                  errorMessage || classicBluetooth.getLastError?.() || 'Classic Bluetooth send failed',
                  conn.deviceId
                ))
              })
            },
            (chunkPct: number) => {
              if (onProgress && typeof chunkPct === 'number') {
                try {
                  onProgress(Math.max(0, Math.min(99, Math.floor(chunkPct))))
                } catch (_) {}
              }
            },
          )
          if (started === false) {
            clearTimeout(asyncTimeoutTimer)
            finish(() => reject(buildClassicBluetoothError('Classic Bluetooth async send start failed', conn.deviceId)))
          }
          return
        }
        finish(() => reject(buildClassicBluetoothError('Classic Bluetooth async API missing', conn.deviceId)))
      }

      const waitReadyAndSend = (startMs: number) => {
        const { ready } = isReady()
        if (ready) {
          sendNow()
          return
        }
        if (Date.now() - startMs > 1500) {
          const errorMessage = typeof classicBluetooth.getLastError === 'function'
            ? classicBluetooth.getLastError()
            : ''
          finish(() => reject(buildClassicBluetoothError(errorMessage || 'Classic Bluetooth connection is not ready', conn.deviceId)))
          return
        }
        setTimeout(() => waitReadyAndSend(startMs), 120)
      }

      /**
       * 新型号/部分安卓机：连接建立慢，或页面切换后 socket 丢失但 UI 仍显示已连。
       * 发送前补连一次，再等短时间就绪。
       */
      try {
        const { ready } = isReady()
        if (!ready && typeof classicBluetooth.ensureConnection === 'function') {
          classicBluetooth.ensureConnection(conn.deviceId)
        }
      } catch (_) {}
      waitReadyAndSend(Date.now())
    } catch (e: any) {
      finish(() => reject(buildClassicBluetoothError(e?.message || String(e || 'Classic Bluetooth send exception'), conn.deviceId)))
    }
  })
  // #endif
  // #ifndef APP-PLUS
  return Promise.reject(new Error('Classic Bluetooth is only available in the app.'))
  // #endif
}

function sendViaBuiltin (data: number[]): Promise<void> {
  // #ifdef APP-PLUS
  try {
    const sendViaBuiltinTcpLocalhost = (): Promise<void> => {
      const u = uni as any
      const moeTcp = u.requireNativePlugin ? u.requireNativePlugin('moe-tcp-client') : null
      if (!moeTcp) {
        return Promise.reject(new Error('BUILTIN_PLUGIN_NOT_FOUND'))
      }
      const uint8 = new Uint8Array(data.length)
      for (let i = 0; i < data.length; i++) uint8[i] = data[i] & 0xff
      const hexStr = Array.from(uint8)
        .map(b => ('0' + (b & 0xff).toString(16)).slice(-2))
        .join('')
      printRunDiag('builtin_tcp_hex_ready', { dataBytes: data.length, hexLen: hexStr.length })

      const savedPort = parseInt(uni.getStorageSync(STORAGE_BUILTIN_PORT)) || 0
      const ports = savedPort > 0
        ? [savedPort, ...BUILTIN_PROBE_PORTS.filter(p => p !== savedPort)]
        : [...BUILTIN_PROBE_PORTS]

      function tryPort (idx: number): Promise<void> {
        if (idx >= ports.length) {
          return Promise.reject(new Error(
            'Built-in printer: all ports failed (tried ' + BUILTIN_PROBE_PORTS.join(', ') +
            '). Check if the printer service is running on this device.'
          ))
        }
        const port = ports[idx]
        return new Promise((resolve, reject) => {
          console.log('[builtin] trying 127.0.0.1:' + port)
          let settled = false
          const timeoutId = setTimeout(() => {
            if (settled) return
            settled = true
            console.warn('[builtin] port connect timeout:', port)
            try { moeTcp.disconnect() } catch (_) {}
            tryPort(idx + 1).then(resolve).catch(reject)
          }, 2500)
          moeTcp.connect({ ip: '127.0.0.1', port }, (res: string) => {
            if (settled) return
            settled = true
            clearTimeout(timeoutId)
            try {
              const r = typeof res === 'string' ? JSON.parse(res) : res
              if (r.code !== 1) {
                console.log('[builtin] port ' + port + ' failed: ' + (r.msg || ''))
                try { moeTcp.disconnect() } catch (_) {}
                tryPort(idx + 1).then(resolve).catch(reject)
                return
              }
              console.log('[builtin] connected on port ' + port)
              uni.setStorageSync(STORAGE_BUILTIN_PORT, String(port))
              moeTcp.sendHexStr({ message: hexStr })
              setTimeout(() => {
                try { moeTcp.disconnect() } catch (_) {}
                resolve()
              }, 300)
            } catch (e) {
              try { moeTcp.disconnect() } catch (_) {}
              tryPort(idx + 1).then(resolve).catch(reject)
            }
          })
        })
      }
      return tryPort(0)
    }

    // rk3568 类一体机：优先走 UnifiedPOS 内置/串口直打（无需蓝牙配对、无需 localhost 端口服务）
    const fingerprint = getDeviceFingerprint()
    const uposOptions = getUposOptionsFromStorage()
    const matchesKeywords = !!fingerprint
      && (fingerprint.includes('rk3568') || fingerprint.includes('aoa_rk3568'))
    const uposSupported = isNativeUposPrintSupported()
    const shouldTryUpos = uposSupported && (uposOptions.force || matchesKeywords)
    const shouldPreferTcpFirst = matchesKeywords && !uposOptions.force && uposOptions.prefer !== 'serial'
    console.warn(
      '[builtin] route decision'
      + ' fingerprint=' + String(fingerprint || '-')
      + ' uposSupported=' + String(!!uposSupported)
      + ' keywordMatched=' + String(!!matchesKeywords)
      + ' uposForce=' + String(!!uposOptions.force)
      + ' shouldTryUpos=' + String(!!shouldTryUpos)
      + ' uposPrefer=' + String(uposOptions.prefer || '-')
      + ' uposSerialPath=' + String(uposOptions.serialPath || '-')
      + ' uposBaudrate=' + String(uposOptions.baudrate || '-')
      + ' dataBytes=' + String(data?.length || 0)
    )
    printRunDiag('builtin_route_decision', {
      fingerprint: String(fingerprint || '-').slice(0, 96),
      shouldTryUpos,
      shouldPreferTcpFirst,
      dataBytes: data.length,
    })
    const runUposPrint = (): Promise<void> => {
      const tB64 = Date.now()
      const base64 = numberArrayToBase64(data)
      printRunDiag('builtin_base64_encoded', {
        ms: Date.now() - tB64,
        dataBytes: data.length,
        base64Len: base64 ? base64.length : 0,
      })
      if (!base64) {
        return Promise.reject(new Error('BASE64_ENCODE_FAILED'))
      }
      console.warn(
        '[builtin] using UPOS printUposCommandBytes'
        + ' prefer=' + String(uposOptions.prefer || '-')
        + ' serialPath=' + String(uposOptions.serialPath || '-')
        + ' baudrate=' + String(uposOptions.baudrate || '-')
        + ' base64Len=' + String(base64.length || 0)
      )
      printRunDiag('builtin_upos_invoke', {
        prefer: uposOptions.prefer || 'builtin',
        baudrate: uposOptions.baudrate || 9600,
      })
      /**
       * 大光栅 ESC/POS 下发可能 >30s；原生 printUposCommandBytes 自身有 300s 超时。
       * 切勿再用 18s Promise.race：否则会误判失败并回退 localhost TCP，大包 hex 发送极易卡数分钟且无纸。
       */
      const tUpos = Date.now()
      const uposJob = printNativeUposCommandBytes({
        base64,
        prefer: uposOptions.prefer,
        serialPath: uposOptions.serialPath,
        baudrate: uposOptions.baudrate,
      }).then(async () => {
        printRunDiag('builtin_upos_js_callback_ok', { waitMs: Date.now() - tUpos })
        let debugInfo: any = null
        try {
          debugInfo = await getNativeFastPrinterDebugInfo()
        } catch (_) {
          debugInfo = null
        }
        printRunDiag('builtin_upos_debug_after', {
          stage: String(debugInfo?.stage || '-'),
          commandBytes: Number(debugInfo?.commandBytes || 0),
          writeMs: Number(debugInfo?.writeMs || 0),
        })
        const stage = String(debugInfo?.stage || '').toLowerCase()
        const commandBytes = Number(debugInfo?.commandBytes || 0)
        const hasWriteMs = Number(debugInfo?.writeMs || 0) > 0
        const okStage = stage.includes('printuposcommandbytes:ok')
        const looksWritten = commandBytes > 0 || hasWriteMs
        if (!okStage || !looksWritten) {
          const detail = [
            'UPOS_VERIFY_FAILED',
            `stage=${String(debugInfo?.stage || '-')}`,
            `lastError=${String(debugInfo?.lastError || '-')}`,
            `commandBytes=${String(debugInfo?.commandBytes ?? '-')}`,
            `writeMs=${String(debugInfo?.writeMs ?? '-')}`,
          ].join('\n')
          throw new Error(detail)
        }
      })

      return uposJob.catch((e: any) => {
        const msg = e instanceof Error ? e.message : String(e || 'UPOS_PRINT_FAILED')
        printRunDiag('builtin_upos_fail_fallback_tcp', { err: msg.slice(0, 240), waitMs: Date.now() - tUpos })
        console.warn('[builtin] UPOS failed/timeout, fallback localhost TCP', msg)
        return sendViaBuiltinTcpLocalhost()
      })
    }

    if (shouldTryUpos && !shouldPreferTcpFirst) {
      return runUposPrint()
    }

    if (shouldPreferTcpFirst) {
      return sendViaBuiltinTcpLocalhost().catch((tcpErr: any) => {
        const tcpMsg = tcpErr instanceof Error ? tcpErr.message : String(tcpErr || 'BUILTIN_TCP_FAILED')
        console.warn('[builtin] localhost TCP failed, fallback UPOS', tcpMsg)
        if (!shouldTryUpos) {
          return Promise.reject(new Error(tcpMsg))
        }
        return runUposPrint()
      })
    }

    return sendViaBuiltinTcpLocalhost()
  } catch (e) {
    return Promise.reject(e)
  }
  // #endif
  // #ifndef APP-PLUS
  return Promise.reject(new Error('Built-in printer is only available in the app. Use Bluetooth printer on this device.'))
  // #endif
}