import TencentCloudChat from '@tencentcloud/lite-chat'
import TIMUploadPlugin from 'tim-upload-plugin'
import { createApp, nextTick, readonly, ref } from 'vue'
import {
  NAME,
  StoreName,
  TUIStore,
  TUICallKitAPI,
  TUICallType,
} from '@trtc/calls-uikit-vue'

import App from './App.vue'
import './style.css'

type CallPhase = 'ready' | 'starting' | 'dialing' | 'connected' | 'ended' | 'error'
type CompanionMode = 'chat' | 'video'
type ChatMessageType = 'text' | 'image' | 'file' | 'audio' | 'video' | 'system' | 'call-status'
type VideoCallStatus = 'starting' | 'dialing' | 'connected' | 'ended' | 'failed'
type TranscriptionState = 'idle' | 'starting' | 'recording' | 'stopping' | 'error'
type LocalRecordingState = 'idle' | 'starting' | 'recording' | 'stopping' | 'uploading' | 'error'

interface NormalizedCallConfig {
  SDKAppID: number
  userID: string
  userSig: string
  targetUserId: string
  diagnosisId: number | string
  patientName: string
  mode: CompanionMode
}

interface UiChatMessage {
  id: string
  mine: boolean
  type: ChatMessageType
  text: string
  url: string
  name: string
  time: string
  callStatus?: VideoCallStatus
}

interface UiLiveCaption {
  id: string
  speaker: string
  text: string
  completed: boolean
}

interface BridgeMessage {
  source: 'doctor-call'
  event:
    | 'ready'
    | 'call-start-request'
    | 'status'
    | 'room'
    | 'hangup'
    | 'error'
    | 'transcription-start-request'
    | 'transcription-segment'
    | 'transcription-stop'
  diagnosisId?: number | string
  status?: string
  roomId?: string
  message?: string
  sessionId?: string
  language?: string
  segment?: {
    segment_id: string
    speaker_user_id: string
    speaker_role: 'doctor' | 'patient' | 'unknown'
    timestamp: number
    text: string
  }
}

interface RealtimeTranscriberMessage {
  segmentId: string
  speakerUserId: string
  sourceText: string
  timestamp: number
  isCompleted: boolean
}

interface RealtimeTranscriberListener {
  onReceiveTranscriberMessage: (
    roomId: string | number,
    message: RealtimeTranscriberMessage,
  ) => void
  onRealtimeTranscriberStarted: (
    roomId: string | number,
    robotId: string,
    sourceLanguage: string,
  ) => void
  onRealtimeTranscriberStopped: (roomId: string | number, robotId: string) => void
  onRealtimeTranscriberError: (
    roomId: string | number,
    robotId: string,
    error: number,
    errorMessage: string,
  ) => void
}

interface RealtimeTranscriberManager {
  addListener(listener: RealtimeTranscriberListener): void
  removeListener(listener: RealtimeTranscriberListener): void
  startRealtimeTranscriber(config: { sourceLanguage: string }): Promise<string>
  stopRealtimeTranscriber(robotId: string): Promise<void>
}

interface PendingTranscriptionReply {
  sessionId: string
  resolve: (value: boolean) => void
  promise: Promise<boolean>
}

interface PendingSegment {
  message: BridgeMessage
  attempts: number
}

interface PendingLocalRecordingReply {
  resolve: (value: boolean) => void
  promise: Promise<boolean>
}

interface TrtcAudioTrackEvent {
  userId?: string
  track?: MediaStreamTrack
}

interface TrtcAudioCloud {
  getAudioTrack?(configOrUserId?: {
    userId?: string
    processed?: boolean
  } | string): MediaStreamTrack | null
  on?(event: 'track', handler: (event: TrtcAudioTrackEvent) => void): void
  off?(event: 'track', handler: (event: TrtcAudioTrackEvent) => void): void
}

const phase = ref<CallPhase>('ready')
const statusText = ref('正在连接问诊服务')
const patientName = ref('患者')
const mode = ref<CompanionMode>('video')
const messages = ref<UiChatMessage[]>([])
const chatReady = ref(false)
const chatBusy = ref(false)
const notice = ref('')
const hasMoreMessages = ref(false)
const transcriptionState = ref<TranscriptionState>('idle')
const localRecordingState = ref<LocalRecordingState>('idle')
const liveCaptions = ref<UiLiveCaption[]>([])

let activeConfig: NormalizedCallConfig | null = null
let chat: any = null
let chatReadyPromise: Promise<void> | null = null
let resolveChatReady: (() => void) | null = null
let rejectChatReady: ((reason?: unknown) => void) | null = null
let nextReqMessageID = ''
let endNotified = true
let starting = false
let emittedRoomId = ''
let pendingRoomId = ''
let boundRoomId = ''
let roomBindingSentAt = 0
let roomBindingAttempts = 0
let resolveHostCallReady: ((value: boolean) => void) | null = null
const pendingTranscriptionStarts = new Map<string, PendingTranscriptionReply>()
const pendingTranscriptionStops = new Map<string, PendingTranscriptionReply>()
let transcriptionSessionId = ''
let transcriptionGeneration = 0
let transcriberRunning = false
let transcriberManager: RealtimeTranscriberManager | null = null
let transcriberListener: RealtimeTranscriberListener | null = null
let transcriberRobotId = ''
let transcriptionStartPromise: Promise<void> | null = null
let transcriptionStopPromise: Promise<void> | null = null
let hangupNotification: Promise<void> | null = null
let callCycleGeneration = 0
let autoTranscriptionAttemptedGeneration = -1
let autoLocalRecordingAttemptedGeneration = -1
let lastTranscriberMessageAt = 0
let transcriberStoppedAt = 0
const acknowledgedSegmentIds = new Set<string>()
const pendingSegments = new Map<string, PendingSegment>()
const pendingLocalRecordingStarts = new Map<string, PendingLocalRecordingReply>()
const pendingLocalRecordingFinishes = new Map<string, PendingLocalRecordingReply>()
let localRecordingSessionId = ''
let localRecordingMimeType = ''
let localRecorder: MediaRecorder | null = null
let localAudioContext: AudioContext | null = null
let localAudioDestination: MediaStreamAudioDestinationNode | null = null
let localAudioCloud: TrtcAudioCloud | null = null
let localAudioTrackHandler: ((event: TrtcAudioTrackEvent) => void) | null = null
let localAudioSources: MediaStreamAudioSourceNode[] = []
let localAudioTrackIds = new Set<string>()
let localAudioOwnedTracks: MediaStreamTrack[] = []
let localAudioDiscoveryTimer: number | null = null
let localAudioHasDoctorSource = false
let localAudioHasPatientSource = false
let localRecordingAttachedSourceCount = 0
let localRecordingChunkSequence = 0
let localRecordingBytes = 0
let localRecordingChunkChain: Promise<void> = Promise.resolve()
let localRecordingStartPromise: Promise<void> | null = null
let localRecordingStopPromise: Promise<void> | null = null
let localRecordingFatalError = ''
let liveCaptionClearTimer: number | null = null

function initializeQtWebChannel(): void {
  const transport = window.qt?.webChannelTransport
  const QWebChannel = window.QWebChannel
  if (!transport || typeof QWebChannel !== 'function') return

  try {
    new QWebChannel(transport, (channel) => {
      const bridge = channel.objects.qtVideoBridge
      if (bridge) window.qtVideoBridge = bridge
      emit({ source: 'doctor-call', event: 'ready' })
    })
  } catch {
    console.warn('[doctor-consultation] Qt 通信通道初始化失败')
  }
}

function postToHost(message: BridgeMessage): boolean {
  let delivered = false
  try {
    if (window.parent && window.parent !== window) {
      window.parent.postMessage(message, '*')
      delivered = true
    }
  } catch {
    // The Qt bridge remains the primary transport.
  }
  try {
    if (window.opener && !window.opener.closed) {
      window.opener.postMessage(message, '*')
      delivered = true
    }
  } catch {
    // A detached opener is harmless.
  }
  return delivered
}

function emit(message: BridgeMessage): void {
  const bridge = window.qtVideoBridge
  if (bridge && typeof bridge.notify === 'function') {
    try {
      bridge.notify(JSON.stringify(message))
      return
    } catch {
      // Fall through to browser messaging when the bridge has detached.
    }
  }
  if (!postToHost(message)) {
    console.info('[doctor-consultation]', message.event, message.status ?? message.message ?? '')
  }
}

function cleanString(value: unknown, field: string): string {
  if (typeof value !== 'string' || value.trim() === '') throw new Error(`${field}不能为空`)
  return value.trim()
}

function normalizeConfig(config: DoctorCallConfig): NormalizedCallConfig {
  if (!config || typeof config !== 'object') throw new Error('问诊配置无效')
  const SDKAppID = Number(config.SDKAppID ?? config.sdkAppId)
  if (!Number.isSafeInteger(SDKAppID) || SDKAppID <= 0) throw new Error('SDKAppID 必须是正整数')

  const diagnosisId = config.diagnosisId
  if (diagnosisId === undefined || diagnosisId === null || String(diagnosisId).trim() === '') {
    throw new Error('诊单ID不能为空')
  }

  return {
    SDKAppID,
    userID: cleanString(config.userID ?? config.userId, '医生用户ID'),
    userSig: cleanString(config.userSig, '用户签名'),
    targetUserId: cleanString(config.targetUserId ?? config.patientUserId, '患者用户ID'),
    diagnosisId: typeof diagnosisId === 'string' ? diagnosisId.trim() : diagnosisId,
    patientName: typeof config.patientName === 'string' && config.patientName.trim()
      ? config.patientName.trim()
      : '患者',
    mode: config.mode === 'chat' ? 'chat' : 'video',
  }
}

function safeErrorMessage(error: unknown, fallback = '问诊服务发生未知错误'): string {
  let message = error instanceof Error ? error.message : fallback
  if (activeConfig?.userSig) message = message.split(activeConfig.userSig).join('[已隐藏]')
  message = message
    .replace(/(user\s*sig\s*[:=]\s*)[^\s,;&]+/gi, '$1[已隐藏]')
    .slice(0, 400)
  if (/user\s+not\s+logged\s+in|not\s+logged\s+in/i.test(message)) {
    return 'IM 登录已失效，请关闭其他患者 IM 窗口后重新打开本会话'
  }
  if (/sdk.*not.*ready|not.*ready/i.test(message)) {
    return 'IM 连接尚未就绪，请稍后重试'
  }
  if (/user\s*sig.*expired|signature.*expired/i.test(message)) {
    return 'IM 登录凭证已过期，请关闭窗口后重新打开'
  }
  return message || fallback
}

function timeText(raw: unknown): string {
  const seconds = Number(raw)
  const date = Number.isFinite(seconds) && seconds > 0 ? new Date(seconds * 1000) : new Date()
  return date.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit', hour12: false })
}

function messageUrl(payload: any): string {
  if (!payload || typeof payload !== 'object') return ''
  if (typeof payload.url === 'string') return payload.url
  if (typeof payload.fileUrl === 'string') return payload.fileUrl
  if (typeof payload.videoUrl === 'string') return payload.videoUrl
  if (typeof payload.remoteAudioUrl === 'string') return payload.remoteAudioUrl
  const images = Array.isArray(payload.imageInfoArray) ? payload.imageInfoArray : []
  const image = images.find((item: any) => item?.type === 0) ?? images.at(-1) ?? images[0]
  return typeof image?.url === 'string' ? image.url : ''
}

function parseJsonObject(value: unknown): Record<string, any> | null {
  if (value && typeof value === 'object' && !Array.isArray(value)) {
    return value as Record<string, any>
  }
  if (typeof value !== 'string' || !value.trim()) return null
  try {
    const parsed = JSON.parse(value)
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
      ? parsed as Record<string, any>
      : null
  } catch {
    return null
  }
}

function customMessageContent(payload: any): { hidden: boolean; text: string } {
  const outer = parseJsonObject(payload?.data) ?? parseJsonObject(payload) ?? {}
  const inner = parseJsonObject(outer.data) ?? {}
  const businessID = outer.businessID ?? outer.businessId ?? inner.businessID ?? inner.businessId
  if (businessID === 1 || String(businessID).toLowerCase().includes('call')) {
    return { hidden: true, text: '' }
  }
  const command = String(outer.command ?? outer.cmd ?? inner.command ?? inner.cmd ?? '').toLowerCase()
  if (command.includes('call') || command.includes('invite')) {
    return { hidden: true, text: '' }
  }
  const text = [
    payload?.description,
    outer.text,
    outer.content,
    outer.message,
    outer.tips,
    inner.text,
    inner.content,
    inner.message,
  ].find((value) => typeof value === 'string' && value.trim())
  return { hidden: false, text: text ? String(text).trim() : '系统自定义消息' }
}

function normalizeMessage(raw: any): UiChatMessage | null {
  const payload = raw?.payload ?? {}
  const rawType = String(raw?.type ?? '')
  let type: ChatMessageType = 'system'
  let text = '系统消息'
  if (rawType === TencentCloudChat.TYPES.MSG_TEXT) {
    type = 'text'
    text = String(payload.text ?? '')
  } else if (rawType === TencentCloudChat.TYPES.MSG_IMAGE) {
    type = 'image'
    text = '[图片]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_FILE) {
    type = 'file'
    text = '[文件]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_AUDIO) {
    type = 'audio'
    text = '[语音]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_VIDEO) {
    type = 'video'
    text = '[视频]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_CUSTOM) {
    const custom = customMessageContent(payload)
    if (custom.hidden) return null
    text = custom.text
  } else if (rawType === TencentCloudChat.TYPES.MSG_FACE) {
    text = '[表情消息]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_LOCATION) {
    text = `[位置] ${String(payload.description ?? payload.name ?? '').trim()}`.trim()
  } else if (rawType === TencentCloudChat.TYPES.MSG_MERGER) {
    text = `[合并消息] ${String(payload.title ?? '').trim()}`.trim()
  } else if (rawType === TencentCloudChat.TYPES.MSG_GRP_TIP) {
    text = '[群组通知]'
  } else if (rawType === TencentCloudChat.TYPES.MSG_GRP_SYS_NOTICE) {
    text = '[群组系统通知]'
  }
  return {
    id: String(raw?.ID ?? raw?.id ?? `${raw?.time ?? Date.now()}-${Math.random()}`),
    mine: Boolean(raw?.flow === 'out' || raw?.from === activeConfig?.userID),
    type,
    text,
    url: messageUrl(payload),
    name: String(payload.fileName ?? payload.name ?? (type === 'file' ? '文件' : '')),
    time: timeText(raw?.time),
  }
}

function mergeMessages(rawList: any[], prepend = false): void {
  const incoming = rawList
    .map(normalizeMessage)
    .filter((item): item is UiChatMessage => item !== null)
  const combined = prepend ? [...incoming, ...messages.value] : [...messages.value, ...incoming]
  const seen = new Set<string>()
  messages.value = combined.filter((item) => {
    if (seen.has(item.id)) return false
    seen.add(item.id)
    return true
  })
}

function appendVideoCallStatus(callStatus: VideoCallStatus, text: string): void {
  if (!activeConfig || activeConfig.mode !== 'chat') return
  const id = `local-video-call-${callCycleGeneration}-${callStatus}`
  const message: UiChatMessage = {
    id,
    mine: false,
    type: 'call-status',
    text,
    url: '',
    name: '',
    time: timeText(undefined),
    callStatus,
  }
  const existingIndex = messages.value.findIndex((item) => item.id === id)
  if (existingIndex < 0) {
    messages.value = [...messages.value, message]
    return
  }
  const next = [...messages.value]
  next[existingIndex] = { ...next[existingIndex], ...message }
  messages.value = next
}

function onMessageReceived(event: any): void {
  if (!activeConfig) return
  const expected = `C2C${activeConfig.targetUserId}`
  const list = Array.isArray(event?.data) ? event.data : []
  const matched = list.filter((item: any) => {
    const conversationID = String(item?.conversationID ?? '')
    return conversationID === expected || item?.from === activeConfig?.targetUserId
  })
  if (!matched.length) return
  mergeMessages(matched)
  void chat?.setMessageRead?.({ conversationID: expected })
}

function onSdkReady(): void {
  chatReady.value = true
  statusText.value = 'IM 已连接'
  notice.value = ''
  resolveChatReady?.()
  resolveChatReady = null
  rejectChatReady = null
}

function onSdkNotReady(event: any): void {
  const wasReady = chatReady.value
  chatReady.value = false
  statusText.value = 'IM 连接已断开'
  if (wasReady) {
    notice.value = safeErrorMessage(event?.data?.message ?? event?.message, 'IM 连接已断开，请重新打开会话')
  }
}

function onKickedOut(event: any): void {
  chatReady.value = false
  statusText.value = 'IM 已在其他窗口登录'
  const type = String(event?.data?.type ?? event?.data ?? '')
  notice.value = type.includes('userSigExpired')
    ? 'IM 登录凭证已过期，请关闭窗口后重新打开'
    : '当前账号已在另一个 IM 窗口登录，请关闭其他患者 IM 窗口后重新打开本会话'
}

function onNetStateChange(event: any): void {
  const state = String(event?.data?.state ?? event?.data ?? '').toUpperCase()
  if (state.includes('DISCONNECTED')) {
    statusText.value = 'IM 网络连接中断，正在自动恢复'
  } else if (state.includes('CONNECTED') && chatReady.value) {
    statusText.value = 'IM 已连接'
  }
}

async function loginChat(): Promise<void> {
  if (!activeConfig) throw new Error('问诊配置尚未准备好')
  chatReady.value = false
  statusText.value = '正在连接患者 IM'
  chat = TencentCloudChat.create({ SDKAppID: activeConfig.SDKAppID })
  chat.setLogLevel(2)
  chat.registerPlugin({ 'tim-upload-plugin': TIMUploadPlugin })
  chat.on(TencentCloudChat.EVENT.SDK_READY, onSdkReady)
  chat.on(TencentCloudChat.EVENT.SDK_NOT_READY, onSdkNotReady)
  chat.on(TencentCloudChat.EVENT.KICKED_OUT, onKickedOut)
  chat.on(TencentCloudChat.EVENT.NET_STATE_CHANGE, onNetStateChange)
  chat.on(TencentCloudChat.EVENT.MESSAGE_RECEIVED, onMessageReceived)
  chatReadyPromise = new Promise<void>((resolve, reject) => {
    resolveChatReady = resolve
    rejectChatReady = reject
  })
  await chat.login({ userID: activeConfig.userID, userSig: activeConfig.userSig })
  await Promise.race([
    chatReadyPromise,
    new Promise<void>((_, reject) => window.setTimeout(() => reject(new Error('IM 连接超时')), 15000)),
  ])
  await loadMessages(false)
}

async function logoutChat(): Promise<void> {
  if (!chat) return
  try {
    chat.off(TencentCloudChat.EVENT.SDK_READY, onSdkReady)
    chat.off(TencentCloudChat.EVENT.SDK_NOT_READY, onSdkNotReady)
    chat.off(TencentCloudChat.EVENT.KICKED_OUT, onKickedOut)
    chat.off(TencentCloudChat.EVENT.NET_STATE_CHANGE, onNetStateChange)
    chat.off(TencentCloudChat.EVENT.MESSAGE_RECEIVED, onMessageReceived)
    await chat.logout()
  } catch {
    // Closing the desktop window must not be blocked by a stale IM connection.
  } finally {
    chat = null
    chatReady.value = false
    chatReadyPromise = null
    resolveChatReady = null
    rejectChatReady = null
  }
}

async function reconnectChat(): Promise<void> {
  if (!activeConfig || activeConfig.mode !== 'chat') throw new Error('当前不是 IM 会话')
  notice.value = ''
  await logoutChat()
  await loginChat()
}

async function loadMessages(prepend: boolean): Promise<void> {
  if (!chat || !activeConfig || chatBusy.value) return
  chatBusy.value = true
  try {
    const request: {
      conversationID: string
      count: number
      nextReqMessageID?: string
    } = {
      conversationID: `C2C${activeConfig.targetUserId}`,
      count: 30,
    }
    // Tencent Cloud IM requires the first roaming-history request to omit the
    // pagination cursor.  Passing an empty string is not equivalent and can
    // return an empty page even though the C2C conversation has history.
    if (prepend && nextReqMessageID) request.nextReqMessageID = nextReqMessageID
    const response = await chat.getMessageList(request)
    const data = response?.data ?? {}
    const list = Array.isArray(data.messageList) ? data.messageList : []
    nextReqMessageID = String(data.nextReqMessageID ?? '')
    hasMoreMessages.value = !Boolean(data.isCompleted) && Boolean(nextReqMessageID)
    mergeMessages(list, prepend)
    await chat.setMessageRead({ conversationID: `C2C${activeConfig.targetUserId}` })
  } catch (error) {
    notice.value = `读取消息失败：${safeErrorMessage(error)}`
  } finally {
    chatBusy.value = false
  }
}

async function sendText(text: string): Promise<void> {
  if (
    !chat
    || !activeConfig
    || !chatReady.value
    || !chat.isReady?.()
    || chat.getLoginUser?.() !== activeConfig.userID
  ) {
    chatReady.value = false
    statusText.value = 'IM 登录已失效'
    throw new Error('IM 登录已失效，请关闭其他患者 IM 窗口后重新打开本会话')
  }
  const content = text.trim()
  if (!content) return
  try {
    const message = chat.createTextMessage({
      to: activeConfig.targetUserId,
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { text: content },
    })
    const response = await chat.sendMessage(message)
    mergeMessages([response?.data?.message ?? response?.data ?? message])
  } catch (error) {
    throw new Error(safeErrorMessage(error, '消息发送失败'))
  }
}

async function sendAttachment(file: File): Promise<void> {
  if (
    !chat
    || !activeConfig
    || !chatReady.value
    || !chat.isReady?.()
    || chat.getLoginUser?.() !== activeConfig.userID
  ) {
    chatReady.value = false
    statusText.value = 'IM 登录已失效'
    throw new Error('IM 登录已失效，请关闭其他患者 IM 窗口后重新打开本会话')
  }
  if (file.size > 20 * 1024 * 1024) throw new Error('附件不能超过 20MB')
  const base = {
    to: activeConfig.targetUserId,
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file },
  }
  const message = file.type.startsWith('image/')
    ? chat.createImageMessage(base)
    : chat.createFileMessage(base)
  try {
    const response = await chat.sendMessage(message)
    mergeMessages([response?.data?.message ?? response?.data ?? message])
  } catch (error) {
    throw new Error(safeErrorMessage(error, '附件发送失败'))
  }
}

function newLocalRecordingSessionId(): string {
  const random = window.crypto?.randomUUID?.().replaceAll('-', '')
  const entropy = random || `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`
  return `audio-${entropy.replace(/[^a-zA-Z0-9]/g, '').slice(0, 32)}`
}

function selectLocalRecordingMimeType(): string {
  if (typeof MediaRecorder === 'undefined') return ''
  const candidates = [
    'audio/webm;codecs=opus',
    'audio/webm',
    'audio/ogg;codecs=opus',
    'audio/ogg',
  ]
  return candidates.find((candidate) => MediaRecorder.isTypeSupported(candidate)) ?? ''
}

function requestLocalRecordingStart(sessionId: string, mimeType: string): Promise<boolean> {
  const bridge = window.qtVideoBridge
  if (!bridge || typeof bridge.startLocalAudioRecording !== 'function') {
    return Promise.resolve(false)
  }
  const existing = pendingLocalRecordingStarts.get(sessionId)
  if (existing) return existing.promise
  const pending = {} as PendingLocalRecordingReply
  pending.promise = new Promise<boolean>((resolve) => {
    pending.resolve = resolve
  })
  pendingLocalRecordingStarts.set(sessionId, pending)
  bridge.startLocalAudioRecording(sessionId, mimeType)
  window.setTimeout(() => {
    if (pendingLocalRecordingStarts.get(sessionId) !== pending) return
    pendingLocalRecordingStarts.delete(sessionId)
    pending.resolve(false)
  }, 15000)
  return pending.promise
}

function requestLocalRecordingFinish(sessionId: string, totalBytes: number): Promise<boolean> {
  const bridge = window.qtVideoBridge
  if (!bridge || typeof bridge.finishLocalAudioRecording !== 'function') {
    return Promise.resolve(false)
  }
  const existing = pendingLocalRecordingFinishes.get(sessionId)
  if (existing) return existing.promise
  const pending = {} as PendingLocalRecordingReply
  pending.promise = new Promise<boolean>((resolve) => {
    pending.resolve = resolve
  })
  pendingLocalRecordingFinishes.set(sessionId, pending)
  bridge.finishLocalAudioRecording(sessionId, totalBytes)
  window.setTimeout(() => {
    if (pendingLocalRecordingFinishes.get(sessionId) !== pending) return
    pendingLocalRecordingFinishes.delete(sessionId)
    pending.resolve(false)
  }, 180000)
  return pending.promise
}

function bytesToBase64(bytes: Uint8Array): string {
  let binary = ''
  for (let index = 0; index < bytes.length; index += 1) {
    binary += String.fromCharCode(bytes[index])
  }
  return window.btoa(binary)
}

async function sendLocalRecordingBlob(blob: Blob, sessionId: string): Promise<void> {
  if (!blob.size || sessionId !== localRecordingSessionId) return
  const bridge = window.qtVideoBridge
  if (!bridge || typeof bridge.appendLocalAudioChunk !== 'function') {
    throw new Error('桌面端本地录音分片通道不可用')
  }
  const bytes = new Uint8Array(await blob.arrayBuffer())
  const maxChunkBytes = 8 * 1024
  for (let offset = 0; offset < bytes.length; offset += maxChunkBytes) {
    const chunk = bytes.subarray(offset, Math.min(offset + maxChunkBytes, bytes.length))
    bridge.appendLocalAudioChunk(
      sessionId,
      localRecordingChunkSequence,
      bytesToBase64(chunk),
    )
    localRecordingChunkSequence += 1
    localRecordingBytes += chunk.length
  }
}

function getTrtcAudioCloud(): TrtcAudioCloud | null {
  const engine = TUICallKitAPI.getTUICallEngineInstance?.()
  const cloud = engine?.getTRTCCloudInstance?.() as Partial<TrtcAudioCloud> | null
  return cloud ? cloud as TrtcAudioCloud : null
}

function attachLocalRecordingTrack(
  track: MediaStreamTrack | null | undefined,
  sourceKind: 'doctor' | 'patient' | 'unknown' = 'unknown',
): boolean {
  const context = localAudioContext
  const destination = localAudioDestination
  if (
    !context
    || !destination
    || !track
    || track.kind !== 'audio'
    || track.readyState === 'ended'
  ) return false
  if (sourceKind === 'doctor') localAudioHasDoctorSource = true
  if (sourceKind === 'patient') localAudioHasPatientSource = true
  if (localAudioTrackIds.has(track.id)) return true
  const source = context.createMediaStreamSource(new MediaStream([track]))
  source.connect(destination)
  localAudioSources.push(source)
  localAudioTrackIds.add(track.id)
  localRecordingAttachedSourceCount += 1
  track.addEventListener('ended', () => localAudioTrackIds.delete(track.id), { once: true })
  return true
}

function attachCurrentCallAudioTracks(cloud: TrtcAudioCloud | null): void {
  if (!activeConfig) return
  if (typeof cloud?.getAudioTrack === 'function') {
    try {
      attachLocalRecordingTrack(cloud.getAudioTrack({ processed: true }), 'doctor')
    } catch {
      try {
        attachLocalRecordingTrack(cloud.getAudioTrack(), 'doctor')
      } catch {
        // The rendered media elements below remain a supported fallback.
      }
    }
    try {
      attachLocalRecordingTrack(cloud.getAudioTrack({
        userId: activeConfig.targetUserId,
        processed: true,
      }), 'patient')
    } catch {
      try {
        attachLocalRecordingTrack(cloud.getAudioTrack(activeConfig.targetUserId), 'patient')
      } catch {
        // Remote audio can become available a few frames after connected.
      }
    }
  }

  for (const media of document.querySelectorAll<HTMLMediaElement>('video, audio')) {
    const stream = media.srcObject
    if (!(stream instanceof MediaStream)) continue
    const sourceKind = media.muted ? 'doctor' : 'patient'
    for (const track of stream.getAudioTracks()) {
      attachLocalRecordingTrack(track, sourceKind)
    }
  }
}

async function attachDoctorMicrophoneFallback(): Promise<void> {
  if (localAudioHasDoctorSource || !navigator.mediaDevices?.getUserMedia) return
  const stream = await navigator.mediaDevices.getUserMedia({
    audio: {
      echoCancellation: true,
      noiseSuppression: true,
      autoGainControl: true,
    },
    video: false,
  })
  const tracks = stream.getAudioTracks()
  localAudioOwnedTracks.push(...tracks)
  for (const track of tracks) attachLocalRecordingTrack(track, 'doctor')
}

async function waitForCallAudioTracks(
  cloud: TrtcAudioCloud | null,
  sessionId: string,
  timeoutMs = 7000,
): Promise<void> {
  const startedAt = Date.now()
  let microphoneAttempted = false
  while (Date.now() - startedAt < timeoutMs) {
    if (sessionId !== localRecordingSessionId || endNotified) {
      throw new Error('视频已结束，本机录音未启动')
    }
    attachCurrentCallAudioTracks(cloud)
    const elapsed = Date.now() - startedAt
    if (!localAudioHasDoctorSource && !microphoneAttempted && elapsed >= 800) {
      microphoneAttempted = true
      try {
        await attachDoctorMicrophoneFallback()
      } catch (error) {
        console.warn(
          '[doctor-consultation] 本机麦克风录音兜底不可用',
          safeErrorMessage(error),
        )
      }
    }
    if (
      localAudioTrackIds.size > 0
      && (localAudioHasDoctorSource && localAudioHasPatientSource || elapsed >= 2200)
    ) return
    await new Promise((resolve) => window.setTimeout(resolve, 160))
  }
  if (localAudioTrackIds.size <= 0) {
    throw new Error('未检测到医生或患者的实时语音音轨，请检查麦克风权限')
  }
}

function startCallAudioDiscovery(cloud: TrtcAudioCloud | null): void {
  if (localAudioDiscoveryTimer !== null) window.clearInterval(localAudioDiscoveryTimer)
  localAudioDiscoveryTimer = window.setInterval(() => {
    attachCurrentCallAudioTracks(cloud)
  }, 500)
}

async function cleanupLocalRecordingGraph(): Promise<void> {
  if (localAudioDiscoveryTimer !== null) {
    window.clearInterval(localAudioDiscoveryTimer)
    localAudioDiscoveryTimer = null
  }
  if (localAudioCloud && localAudioTrackHandler && typeof localAudioCloud.off === 'function') {
    try {
      localAudioCloud.off('track', localAudioTrackHandler)
    } catch {
      // The call engine may already have released its event dispatcher.
    }
  }
  localAudioCloud = null
  localAudioTrackHandler = null
  for (const source of localAudioSources) {
    try {
      source.disconnect()
    } catch {
      // A closed AudioContext has already disconnected its graph.
    }
  }
  localAudioSources = []
  localAudioTrackIds.clear()
  for (const track of localAudioOwnedTracks) track.stop()
  localAudioOwnedTracks = []
  localAudioHasDoctorSource = false
  localAudioHasPatientSource = false
  localRecordingAttachedSourceCount = 0
  const context = localAudioContext
  localAudioContext = null
  localAudioDestination = null
  if (context && context.state !== 'closed') {
    try {
      await context.close()
    } catch {
      // Closing the consultation must not be blocked by a released device.
    }
  }
  localRecorder = null
}

async function performStartLocalRecording(): Promise<void> {
  if (!activeConfig || phase.value !== 'connected' || endNotified) {
    throw new Error('视频接通后才能启动本机录音')
  }
  if (!window.qtVideoBridge?.startLocalAudioRecording) {
    throw new Error('桌面端本机录音存储通道不可用')
  }
  const mimeType = selectLocalRecordingMimeType()
  if (!mimeType) throw new Error('当前浏览器不支持 Opus 本机录音')

  localRecordingState.value = 'starting'
  localRecordingFatalError = ''
  localRecordingChunkSequence = 0
  localRecordingBytes = 0
  localRecordingChunkChain = Promise.resolve()
  localRecordingAttachedSourceCount = 0
  localAudioHasDoctorSource = false
  localAudioHasPatientSource = false
  const sessionId = newLocalRecordingSessionId()
  localRecordingSessionId = sessionId
  localRecordingMimeType = mimeType

  try {
    const AudioContextConstructor = window.AudioContext
    const context = new AudioContextConstructor()
    localAudioContext = context
    localAudioDestination = context.createMediaStreamDestination()
    const cloud = getTrtcAudioCloud()
    localAudioCloud = cloud
    localAudioTrackHandler = (event) => attachLocalRecordingTrack(
      event.track,
      event.userId === activeConfig?.userID
        ? 'doctor'
        : event.userId === activeConfig?.targetUserId
          ? 'patient'
          : 'unknown',
    )
    if (typeof cloud?.on === 'function') cloud.on('track', localAudioTrackHandler)
    if (context.state === 'suspended') await context.resume()
    await waitForCallAudioTracks(cloud, sessionId)
    startCallAudioDiscovery(cloud)

    const storageReady = await requestLocalRecordingStart(sessionId, mimeType)
    if (!storageReady || sessionId !== localRecordingSessionId || endNotified) {
      throw new Error(notice.value || '服务端未能创建本机录音临时文件')
    }
    const destination = localAudioDestination
    if (!destination) throw new Error('本机录音混音器未就绪')
    if (localRecordingAttachedSourceCount <= 0) {
      throw new Error('本机录音没有连接到医生或患者语音')
    }
    const recorder = new MediaRecorder(destination.stream, { mimeType })
    localRecorder = recorder
    recorder.addEventListener('dataavailable', (event) => {
      if (!event.data.size || sessionId !== localRecordingSessionId) return
      localRecordingChunkChain = localRecordingChunkChain
        .then(() => sendLocalRecordingBlob(event.data, sessionId))
        .catch((error) => {
          localRecordingFatalError = safeErrorMessage(error, '本机录音分片保存失败')
          localRecordingState.value = 'error'
          notice.value = localRecordingFatalError
          window.qtVideoBridge?.abortLocalAudioRecording?.(sessionId)
          if (recorder.state !== 'inactive') recorder.stop()
        })
    })
    recorder.addEventListener('error', (event) => {
      localRecordingFatalError = safeErrorMessage(
        (event as ErrorEvent).error,
        '浏览器本机录音发生错误',
      )
      localRecordingState.value = 'error'
      notice.value = localRecordingFatalError
    })
    recorder.start(1000)
    localRecordingState.value = 'recording'
    notice.value = '腾讯云混流视频、本机语音录音和实时转写均已启动'
  } catch (error) {
    window.qtVideoBridge?.abortLocalAudioRecording?.(sessionId)
    await cleanupLocalRecordingGraph()
    if (sessionId === localRecordingSessionId) {
      localRecordingSessionId = ''
      localRecordingMimeType = ''
      localRecordingState.value = 'error'
    }
    throw new Error(safeErrorMessage(error, '本机语音录音启动失败'))
  }
}

function startLocalRecording(): Promise<void> {
  if (localRecordingStartPromise) return localRecordingStartPromise
  if (localRecordingState.value === 'recording') return Promise.resolve()
  const operation = performStartLocalRecording()
  const tracked = operation.finally(() => {
    if (localRecordingStartPromise === tracked) localRecordingStartPromise = null
  })
  localRecordingStartPromise = tracked
  return tracked
}

async function performStopLocalRecording(): Promise<void> {
  const startInFlight = localRecordingStartPromise
  if (startInFlight) {
    try {
      await startInFlight
    } catch {
      return
    }
  }
  const sessionId = localRecordingSessionId
  const recorder = localRecorder
  if (!sessionId || !recorder) {
    if (localRecordingState.value !== 'error') localRecordingState.value = 'idle'
    return
  }
  localRecordingState.value = 'stopping'
  try {
    if (recorder.state !== 'inactive') {
      await new Promise<void>((resolve) => {
        recorder.addEventListener('stop', () => resolve(), { once: true })
        recorder.stop()
      })
    }
    await localRecordingChunkChain
    if (localRecordingFatalError) throw new Error(localRecordingFatalError)
    if (localRecordingAttachedSourceCount <= 0) {
      throw new Error('本机录音没有连接到有效语音音轨')
    }
    if (localRecordingBytes < 1024) {
      throw new Error('本机录音文件为空或不完整，已阻止上传空文件')
    }
    localRecordingState.value = 'uploading'
    notice.value = '正在把本机语音录音上传到 COS…'
    const persisted = await requestLocalRecordingFinish(sessionId, localRecordingBytes)
    if (!persisted) throw new Error(notice.value || '本机语音录音上传 COS 失败')
    localRecordingState.value = 'idle'
    notice.value = '混流视频、本机录音和转写文字均已归档到本次通话记录'
  } catch (error) {
    window.qtVideoBridge?.abortLocalAudioRecording?.(sessionId)
    localRecordingState.value = 'error'
    throw new Error(safeErrorMessage(error, '本机语音录音保存失败'))
  } finally {
    await cleanupLocalRecordingGraph()
    if (sessionId === localRecordingSessionId) {
      localRecordingSessionId = ''
      localRecordingMimeType = ''
    }
  }
}

function stopLocalRecording(): Promise<void> {
  if (localRecordingStopPromise) return localRecordingStopPromise
  if (localRecordingState.value === 'idle' && !localRecordingSessionId) return Promise.resolve()
  const operation = performStopLocalRecording()
  const tracked = operation.finally(() => {
    if (localRecordingStopPromise === tracked) localRecordingStopPromise = null
  })
  localRecordingStopPromise = tracked
  return tracked
}

function localRecordingResult(
  operation: 'start' | 'chunk' | 'finish',
  sessionId: string,
  _sequence: number,
  ok: boolean,
  message: string,
): void {
  if (operation === 'start') {
    const pending = pendingLocalRecordingStarts.get(sessionId)
    if (!pending) return
    pendingLocalRecordingStarts.delete(sessionId)
    if (message && sessionId === localRecordingSessionId) notice.value = message
    pending.resolve(Boolean(ok))
  } else if (operation === 'finish') {
    const pending = pendingLocalRecordingFinishes.get(sessionId)
    if (!pending) return
    pendingLocalRecordingFinishes.delete(sessionId)
    if (message && sessionId === localRecordingSessionId) notice.value = message
    pending.resolve(Boolean(ok))
  } else if (!ok && sessionId === localRecordingSessionId) {
    localRecordingFatalError = message || '本机录音分片保存失败'
    localRecordingState.value = 'error'
    notice.value = localRecordingFatalError
    window.qtVideoBridge?.abortLocalAudioRecording?.(sessionId)
    if (localRecorder && localRecorder.state !== 'inactive') localRecorder.stop()
  }
}

function newTranscriptionSessionId(): string {
  // Keep this identity within 32 ASCII characters.  Some upgraded deployments
  // still have the legacy varchar(32) column; a UUID with hyphens was silently
  // truncated there, so the first transcript segment no longer matched the
  // session that startCallTranscription had acknowledged.
  const random = window.crypto?.randomUUID?.().replaceAll('-', '')
  const entropy = random || `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`
  return `tr-${entropy.replace(/[^a-zA-Z0-9]/g, '').slice(0, 28)}`
}

function requestTranscriptionStart(sessionId: string): Promise<boolean> {
  if (!activeConfig || !window.qtVideoBridge?.notify) return Promise.resolve(false)
  const existing = pendingTranscriptionStarts.get(sessionId)
  if (existing) return existing.promise
  const pending = {} as PendingTranscriptionReply
  pending.sessionId = sessionId
  pending.promise = new Promise<boolean>((resolve) => {
    pending.resolve = resolve
  })
  pendingTranscriptionStarts.set(sessionId, pending)
  emit({
    source: 'doctor-call',
    event: 'transcription-start-request',
    diagnosisId: activeConfig?.diagnosisId,
    sessionId,
    language: 'zh',
  })
  window.setTimeout(() => {
    if (pendingTranscriptionStarts.get(sessionId) !== pending) return
    pendingTranscriptionStarts.delete(sessionId)
    pending.resolve(false)
  }, 15000)
  return pending.promise
}

function requestTranscriptionStop(
  sessionId: string,
  status: 'completed' | 'partial' | 'failed',
): Promise<boolean> {
  if (!activeConfig || !sessionId || !window.qtVideoBridge?.notify) {
    return Promise.resolve(false)
  }
  const existing = pendingTranscriptionStops.get(sessionId)
  if (existing) return existing.promise
  const pending = {} as PendingTranscriptionReply
  pending.sessionId = sessionId
  pending.promise = new Promise<boolean>((resolve) => {
    pending.resolve = resolve
  })
  pendingTranscriptionStops.set(sessionId, pending)
  emit({
    source: 'doctor-call',
    event: 'transcription-stop',
    diagnosisId: activeConfig?.diagnosisId,
    sessionId,
    status,
  })
  window.setTimeout(() => {
    if (pendingTranscriptionStops.get(sessionId) !== pending) return
    pendingTranscriptionStops.delete(sessionId)
    pending.resolve(false)
  }, 15000)
  return pending.promise
}

function getTranscriberManager(): RealtimeTranscriberManager {
  const engine = TUICallKitAPI.getTUICallEngineInstance?.()
  const cloud = engine?.getTRTCCloudInstance?.()
  const manager = cloud?.getAITranscriberManager?.() as Partial<RealtimeTranscriberManager> | null
  if (
    !manager
    || typeof manager.addListener !== 'function'
    || typeof manager.removeListener !== 'function'
    || typeof manager.startRealtimeTranscriber !== 'function'
    || typeof manager.stopRealtimeTranscriber !== 'function'
  ) {
    throw new Error('当前视频服务未开通实时语音转写')
  }
  return manager as RealtimeTranscriberManager
}

function clearLiveCaptions(): void {
  if (liveCaptionClearTimer !== null) {
    window.clearTimeout(liveCaptionClearTimer)
    liveCaptionClearTimer = null
  }
  liveCaptions.value = []
}

function showLiveCaption(message: RealtimeTranscriberMessage): void {
  if (!activeConfig) return
  const text = String(message.sourceText ?? '').trim()
  if (!text) return
  const speakerUserId = String(message.speakerUserId ?? '').trim()
  const segmentId = String(message.segmentId ?? '').trim()
  const id = segmentId || `speaker-${speakerUserId || 'unknown'}`
  const speaker = speakerUserId === activeConfig.userID
    ? '医生'
    : speakerUserId === activeConfig.targetUserId
      ? patientName.value || '患者'
      : '对话'
  const caption: UiLiveCaption = {
    id,
    speaker,
    text: text.slice(0, 500),
    completed: message.isCompleted === true,
  }
  const previous = liveCaptions.value.filter((item) => item.id !== id)
  liveCaptions.value = [...previous, caption].slice(-2)
  if (liveCaptionClearTimer !== null) window.clearTimeout(liveCaptionClearTimer)
  liveCaptionClearTimer = window.setTimeout(() => {
    liveCaptions.value = []
    liveCaptionClearTimer = null
  }, message.isCompleted === true ? 9000 : 5000)
}

function handleTranscriberMessage(
  roomId: string | number,
  message: RealtimeTranscriberMessage,
): void {
  // The realtime transcriber always identifies the active TRTC room.  Use it
  // as a second authoritative source because some CallKit versions clear the
  // ROOM_ID store before the desktop host has persisted it.
  observeRoomId(roomId)
  if (
    !activeConfig
    || !['recording', 'stopping'].includes(transcriptionState.value)
    || !transcriptionSessionId
  ) return
  lastTranscriberMessageAt = Date.now()
  const segmentId = String(message.segmentId ?? '').trim()
  const text = String(message.sourceText ?? '').trim()
  showLiveCaption(message)
  if (message.isCompleted !== true) return
  if (
    !segmentId
    || acknowledgedSegmentIds.has(segmentId)
    || pendingSegments.has(segmentId)
    || !text
  ) return
  const speakerUserId = String(message.speakerUserId ?? '').trim()
  const bridgeMessage: BridgeMessage = {
    source: 'doctor-call',
    event: 'transcription-segment',
    diagnosisId: activeConfig.diagnosisId,
    sessionId: transcriptionSessionId,
    segment: {
      segment_id: segmentId.slice(0, 160),
      speaker_user_id: speakerUserId.slice(0, 160),
      speaker_role: speakerUserId === activeConfig.userID
        ? 'doctor'
        : speakerUserId === activeConfig.targetUserId
          ? 'patient'
          : 'unknown',
      timestamp: Math.max(0, Math.trunc(Number(message.timestamp) || 0)),
      text: text.slice(0, 4000),
    },
  }
  pendingSegments.set(segmentId, { message: bridgeMessage, attempts: 1 })
  emit(bridgeMessage)
}

function subscribeTranscriber(): {
  manager: RealtimeTranscriberManager
  listener: RealtimeTranscriberListener
} {
  if (transcriberManager && transcriberListener) {
    return { manager: transcriberManager, listener: transcriberListener }
  }
  const manager = getTranscriberManager()
  const listener: RealtimeTranscriberListener = {
    onReceiveTranscriberMessage: handleTranscriberMessage,
    onRealtimeTranscriberStarted: (roomId) => {
      observeRoomId(roomId)
    },
    onRealtimeTranscriberStopped: (roomId, robotId) => {
      observeRoomId(roomId)
      if (robotId !== transcriberRobotId) return
      transcriberRunning = false
      transcriberStoppedAt = Date.now()
      if (transcriptionState.value === 'recording') {
        void stopTranscription('partial', true)
      }
    },
    onRealtimeTranscriberError: (roomId, robotId, _error, errorMessage) => {
      observeRoomId(roomId)
      if (robotId !== transcriberRobotId || transcriptionState.value === 'stopping') return
      notice.value = safeErrorMessage(new Error(errorMessage), '实时语音转写发生错误')
      void stopTranscription('partial', true)
    },
  }
  manager.addListener(listener)
  transcriberManager = manager
  transcriberListener = listener
  return { manager, listener }
}

function unsubscribeTranscriber(
  manager = transcriberManager,
  listener = transcriberListener,
): void {
  if (manager && listener) {
    try {
      manager.removeListener(listener)
    } catch {
      // A destroyed call engine has already released the listener.
    }
  }
  if (transcriberManager === manager && transcriberListener === listener) {
    transcriberManager = null
    transcriberListener = null
  }
}

function transcriptionTokenIsCurrent(token: number, sessionId: string): boolean {
  return (
    token === transcriptionGeneration
    && sessionId === transcriptionSessionId
    && transcriptionState.value === 'starting'
    && phase.value === 'connected'
    && !endNotified
  )
}

async function waitForPendingSegments(timeoutMs = 3000, quietMs = 300): Promise<boolean> {
  const startedAt = Date.now()
  const deadline = Date.now() + timeoutMs
  while (Date.now() < deadline) {
    const stoppedOrSettled = transcriberStoppedAt > 0 || Date.now() - startedAt >= 500
    const quiet = Date.now() - lastTranscriberMessageAt >= quietMs
    if (stoppedOrSettled && quiet && pendingSegments.size === 0) return true
    await new Promise((resolve) => window.setTimeout(resolve, 50))
  }
  return false
}

async function performStartTranscription(): Promise<void> {
  if (!activeConfig || phase.value !== 'connected') throw new Error('视频接通后才能开始录音')
  if (transcriptionState.value !== 'idle' && transcriptionState.value !== 'error') {
    throw new Error('录音任务正在处理中')
  }

  transcriptionState.value = 'starting'
  const sessionId = newTranscriptionSessionId()
  const token = ++transcriptionGeneration
  transcriptionSessionId = sessionId
  acknowledgedSegmentIds.clear()
  pendingSegments.clear()
  clearLiveCaptions()
  lastTranscriberMessageAt = Date.now()
  transcriberStoppedAt = 0
  notice.value = '正在准备录音文字存储…'
  const storageReady = await requestTranscriptionStart(sessionId)
  if (!storageReady) {
    if (!transcriptionTokenIsCurrent(token, sessionId)) return
    transcriptionState.value = 'error'
    transcriptionSessionId = ''
    throw new Error(notice.value || '服务端无法保存本次面诊对话文字')
  }
  if (!transcriptionTokenIsCurrent(token, sessionId)) {
    await requestTranscriptionStop(sessionId, 'partial')
    return
  }

  let ownedManager: RealtimeTranscriberManager | null = null
  let ownedListener: RealtimeTranscriberListener | null = null
  try {
    const subscribed = subscribeTranscriber()
    const { manager, listener } = subscribed
    ownedManager = manager
    ownedListener = listener
    const robotId = await manager.startRealtimeTranscriber({
      sourceLanguage: 'zh',
    })
    if (!robotId) throw new Error('当前腾讯云项目未开通实时语音转写')
    if (!transcriptionTokenIsCurrent(token, sessionId)) {
      await manager.stopRealtimeTranscriber(robotId)
      unsubscribeTranscriber(manager, listener)
      return
    }
    transcriberRobotId = robotId
    transcriberRunning = true
    transcriptionState.value = 'recording'
    notice.value = '正在录音并实时转换为对话文字'
  } catch (error) {
    unsubscribeTranscriber(ownedManager, ownedListener)
    await requestTranscriptionStop(sessionId, 'failed')
    if (sessionId === transcriptionSessionId) transcriptionState.value = 'error'
    const message = safeErrorMessage(error, '录音转文字启动失败')
    notice.value = message
    if (sessionId === transcriptionSessionId) transcriptionSessionId = ''
    throw new Error(message)
  }
}

function startTranscription(): Promise<void> {
  if (transcriptionStartPromise) return transcriptionStartPromise
  const operation = performStartTranscription()
  const tracked = operation.finally(() => {
    if (transcriptionStartPromise === tracked) transcriptionStartPromise = null
  })
  transcriptionStartPromise = tracked
  return transcriptionStartPromise
}

async function stopTranscription(
  status: 'completed' | 'partial' | 'failed' = 'completed',
  managerAlreadyStopped = false,
): Promise<void> {
  if (transcriptionStopPromise) return transcriptionStopPromise
  if (transcriptionState.value === 'idle') return
  if (!transcriptionSessionId) {
    transcriptionState.value = 'idle'
    return
  }
  const sessionId = transcriptionSessionId
  const startInFlight = transcriptionStartPromise
  transcriptionGeneration += 1
  transcriptionState.value = 'stopping'
  transcriptionStopPromise = (async () => {
    if (startInFlight) {
      try {
        await startInFlight
      } catch {
        // Its failure is materialized as a failed/partial transcript below.
      }
    }
    let sdkStopped = managerAlreadyStopped
    const manager = transcriberManager
    const robotId = transcriberRobotId
    if (!managerAlreadyStopped && transcriberRunning && manager && robotId) {
      try {
        await manager.stopRealtimeTranscriber(robotId)
        sdkStopped = true
      } catch (error) {
        console.warn('[doctor-consultation] 停止实时转写失败', safeErrorMessage(error))
      }
    }
    transcriberRunning = false
    transcriberRobotId = ''
    const segmentsComplete = await waitForPendingSegments()
    unsubscribeTranscriber()
    const finalStatus = sdkStopped && segmentsComplete ? status : 'partial'
    const persisted = await requestTranscriptionStop(sessionId, finalStatus)
    if (sessionId !== transcriptionSessionId) return
    transcriptionState.value = persisted ? 'idle' : 'error'
    notice.value = persisted
      ? '本次面诊对话文字已保存到视频记录'
      : '对话文字未能完整确认保存，请稍后在面诊记录中检查'
    transcriptionSessionId = ''
    acknowledgedSegmentIds.clear()
    pendingSegments.clear()
    clearLiveCaptions()
  })().finally(() => {
    transcriptionStopPromise = null
  })
  return transcriptionStopPromise
}

function transcriptionResult(
  operation: 'start' | 'segment' | 'stop',
  sessionId: string,
  segmentId: string,
  ok: boolean,
  message: string,
): void {
  if (operation === 'start') {
    const pending = pendingTranscriptionStarts.get(sessionId)
    if (!pending) return
    pendingTranscriptionStarts.delete(sessionId)
    if (message && sessionId === transcriptionSessionId) notice.value = message
    pending.resolve(Boolean(ok))
  } else if (operation === 'stop') {
    const pending = pendingTranscriptionStops.get(sessionId)
    if (!pending) return
    pendingTranscriptionStops.delete(sessionId)
    if (message && sessionId === transcriptionSessionId) notice.value = message
    pending.resolve(Boolean(ok))
  } else if (operation === 'segment' && sessionId === transcriptionSessionId) {
    const pending = pendingSegments.get(segmentId)
    if (!pending) return
    if (ok) {
      pendingSegments.delete(segmentId)
      acknowledgedSegmentIds.add(segmentId)
    } else if (pending.attempts < 3) {
      pending.attempts += 1
      window.setTimeout(() => {
        if (pendingSegments.get(segmentId) === pending) emit(pending.message)
      }, pending.attempts * 250)
    } else {
      notice.value = message || '部分对话文字保存失败，本次记录将标记为部分保存'
    }
  }
}

function notifyHangup(status = 'ended'): Promise<void> {
  if (hangupNotification) return hangupNotification
  if (endNotified) return Promise.resolve()
  endNotified = true
  phase.value = 'ended'
  statusText.value = mode.value === 'chat' ? '视频通话已结束，IM 保持连接' : '视频问诊已结束'
  appendVideoCallStatus('ended', '视频通话已结束')
  hangupNotification = (async () => {
    const operations: Promise<void>[] = []
    if (localRecordingState.value !== 'idle' || localRecordingSessionId) {
      operations.push(stopLocalRecording())
    }
    if (transcriptionState.value !== 'idle') {
      operations.push(stopTranscription('completed'))
    }
    const results = await Promise.allSettled(operations)
    const failures = results
      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
      .map((result) => safeErrorMessage(result.reason, '录音资料收尾失败'))
    if (failures.length) {
      notice.value = failures.join('；').slice(0, 400)
      console.warn('[doctor-consultation] 录音资料收尾失败', notice.value)
    }
    emit({
      source: 'doctor-call',
      event: 'hangup',
      diagnosisId: activeConfig?.diagnosisId,
      status,
    })
  })()
  return hangupNotification
}

function normalizeRoomId(raw: unknown): string {
  if (raw === undefined || raw === null) return ''
  const value = String(raw).trim()
  return value && value !== '0' ? value : ''
}

function readRoomId(): string {
  return normalizeRoomId(TUIStore.getData(StoreName.CALL, NAME.ROOM_ID))
}

function observeRoomId(rawRoomId: unknown): boolean {
  if (!activeConfig || endNotified) return false
  const roomId = normalizeRoomId(rawRoomId)
  if (!roomId) return false
  if (boundRoomId) return boundRoomId === roomId

  const now = Date.now()
  const retryDelay = Math.min(10_000, 750 * (2 ** Math.min(roomBindingAttempts, 4)))
  if (pendingRoomId === roomId && now - roomBindingSentAt < retryDelay) return false

  emittedRoomId = roomId
  pendingRoomId = roomId
  roomBindingSentAt = now
  roomBindingAttempts += 1
  emit({ source: 'doctor-call', event: 'room', diagnosisId: activeConfig.diagnosisId, roomId })
  return false
}

function emitRoomId(): boolean {
  return observeRoomId(readRoomId())
}

async function pollRoomId(): Promise<void> {
  const cycle = callCycleGeneration
  while (activeConfig && !endNotified && cycle === callCycleGeneration) {
    if (boundRoomId) return
    emitRoomId()
    await new Promise((resolve) => window.setTimeout(resolve, 250))
  }
}

function handleRoomIdChanged(): void {
  emitRoomId()
}

const roomIdWatchOptions = {
  [NAME.ROOM_ID]: handleRoomIdChanged,
}
TUIStore.watch(StoreName.CALL, roomIdWatchOptions)

function handleStatusChanged(payload: unknown): void {
  const value = payload && typeof payload === 'object'
    ? (payload as { newStatus?: unknown }).newStatus
    : payload
  const status = typeof value === 'string' ? value : 'unknown'
  if (status === 'connected' || status.startsWith('calling-')) {
    if (endNotified || !activeConfig) return
    const cycle = callCycleGeneration
    phase.value = 'connected'
    statusText.value = '视频问诊进行中'
    appendVideoCallStatus('connected', '视频通话已接通')
    void pollRoomId()
    if (autoTranscriptionAttemptedGeneration !== cycle) {
      autoTranscriptionAttemptedGeneration = cycle
      void startTranscription().catch((error) => {
        if (cycle !== callCycleGeneration || endNotified) return
        notice.value = safeErrorMessage(error, '自动录音转文字启动失败')
      })
    }
    if (autoLocalRecordingAttemptedGeneration !== cycle) {
      autoLocalRecordingAttemptedGeneration = cycle
      void startLocalRecording().catch((error) => {
        if (cycle !== callCycleGeneration || endNotified) return
        notice.value = safeErrorMessage(error, '本机语音录音启动失败')
      })
    }
  } else if (status === 'calling' || status.startsWith('dialing')) {
    if (endNotified || !activeConfig) return
    phase.value = 'dialing'
    statusText.value = '正在等待患者接听'
    appendVideoCallStatus('dialing', '正在等待患者接听')
  } else if (status === 'idle' && activeConfig && !starting) {
    void notifyHangup(status)
  }
  emit({ source: 'doctor-call', event: 'status', diagnosisId: activeConfig?.diagnosisId, status })
}

TUICallKitAPI.setCallback({
  statusChanged: handleStatusChanged,
  afterCalling: () => { void notifyHangup('after-calling') },
})
TUICallKitAPI.setLanguage('zh-cn')
TUICallKitAPI.enableFloatWindow(false)

function requestHostCallStart(): Promise<boolean> {
  if (!activeConfig) return Promise.resolve(false)
  if (!window.qtVideoBridge?.notify) return Promise.resolve(true)
  return new Promise<boolean>((resolve) => {
    const currentResolver = resolve
    resolveHostCallReady = currentResolver
    emit({ source: 'doctor-call', event: 'call-start-request', diagnosisId: activeConfig?.diagnosisId })
    window.setTimeout(() => {
      if (resolveHostCallReady !== currentResolver) return
      resolveHostCallReady = null
      resolve(false)
    }, 15000)
  })
}

function hostCallReady(ok: boolean, message = ''): void {
  const resolver = resolveHostCallReady
  resolveHostCallReady = null
  if (message) notice.value = message
  resolver?.(Boolean(ok))
}

async function startVideo(): Promise<void> {
  if (!activeConfig) throw new Error('问诊配置尚未准备好')
  if (starting || !endNotified) throw new Error('已有视频通话正在进行')
  starting = true
  try {
    if (hangupNotification) await hangupNotification
    if (!activeConfig || !endNotified) throw new Error('已有视频通话正在进行')
    hangupNotification = null
    callCycleGeneration += 1
    endNotified = false
    phase.value = 'starting'
    statusText.value = '正在创建安全视频通话'
    appendVideoCallStatus('starting', '正在创建安全视频通话')
    transcriptionState.value = 'idle'
    transcriptionSessionId = ''
    clearLiveCaptions()
    localRecordingState.value = 'idle'
    localRecordingSessionId = ''
    localRecordingMimeType = ''
    notice.value = ''
    const allowed = await requestHostCallStart()
    if (!allowed) throw new Error(notice.value || '服务器未能创建视频通话记录')
    await TUICallKitAPI.init({
      SDKAppID: activeConfig.SDKAppID,
      userID: activeConfig.userID,
      userSig: activeConfig.userSig,
      ...(chat ? { tim: chat, isFromChat: true } : {}),
    })
    await nextTick()
    phase.value = 'dialing'
    statusText.value = '正在呼叫患者'
    appendVideoCallStatus('dialing', '正在呼叫患者')
    emittedRoomId = ''
    pendingRoomId = ''
    boundRoomId = ''
    roomBindingSentAt = 0
    roomBindingAttempts = 0
    await TUICallKitAPI.calls({
      userIDList: [activeConfig.targetUserId],
      type: TUICallType.VIDEO_CALL,
    })
    void pollRoomId()
    emit({ source: 'doctor-call', event: 'status', diagnosisId: activeConfig.diagnosisId, status: 'dialing' })
  } catch (error) {
    const message = safeErrorMessage(error, '无法发起视频通话')
    phase.value = 'error'
    statusText.value = message
    appendVideoCallStatus('failed', `视频通话发起失败：${message}`)
    endNotified = true
    emit({ source: 'doctor-call', event: 'error', diagnosisId: activeConfig.diagnosisId, message })
    throw new Error(message)
  } finally {
    starting = false
  }
}

async function hangup(): Promise<void> {
  if (!activeConfig) return
  if (endNotified) {
    if (hangupNotification) await hangupNotification
    return
  }
  try {
    await TUICallKitAPI.hangup()
    await notifyHangup('local-hangup')
  } catch (error) {
    const message = safeErrorMessage(error, '结束视频通话失败')
    emit({ source: 'doctor-call', event: 'error', diagnosisId: activeConfig.diagnosisId, message })
    throw new Error(message)
  }
}

async function saveScreenshot(dataUrl: string): Promise<void> {
  const bridge = window.qtVideoBridge
  if (!bridge || typeof bridge.saveScreenshot !== 'function') throw new Error('桌面端截图保存通道不可用')
  bridge.saveScreenshot(dataUrl)
  notice.value = '正在保存截图到患者舌像资料…'
}

function screenshotResult(ok: boolean, message: string): void {
  notice.value = message || (ok ? '截图已保存到患者舌像资料' : '截图保存失败')
}

function recordingResult(ok: boolean, message: string): void {
  notice.value = message || (ok
    ? '通话已自动录制，结束后将由云端完成 COS 文件收尾。'
    : '自动云端录制未启动，请结束本次通话并检查 COS 配置。')
}

function roomBindingResult(roomId: string, ok: boolean, message: string): void {
  const normalized = normalizeRoomId(roomId)
  if (!normalized || (emittedRoomId && normalized !== emittedRoomId)) return
  if (ok) {
    boundRoomId = normalized
    pendingRoomId = ''
  } else if (pendingRoomId === normalized) {
    // Keep the failed room pending so pollRoomId retries it with exponential
    // backoff. The desktop lifecycle releases only failed claims.
  }
  recordingResult(ok, message)
}

async function open(config: DoctorCallConfig): Promise<void> {
  if (activeConfig) await close()
  activeConfig = normalizeConfig(config)
  mode.value = activeConfig.mode
  patientName.value = activeConfig.patientName
  messages.value = []
  nextReqMessageID = ''
  hasMoreMessages.value = false
  endNotified = true
  hangupNotification = null
  callCycleGeneration += 1
  autoTranscriptionAttemptedGeneration = -1
  autoLocalRecordingAttemptedGeneration = -1
  phase.value = 'ready'
  transcriptionState.value = 'idle'
  transcriptionSessionId = ''
  clearLiveCaptions()
  transcriptionGeneration += 1
  transcriberRunning = false
  transcriberRobotId = ''
  acknowledgedSegmentIds.clear()
  pendingSegments.clear()
  localRecordingState.value = 'idle'
  localRecordingSessionId = ''
  localRecordingMimeType = ''
  localRecordingFatalError = ''
  notice.value = ''
  if (activeConfig.mode === 'chat') {
    try {
      await loginChat()
    } catch (error) {
      const message = safeErrorMessage(error, 'IM 连接失败')
      phase.value = 'error'
      statusText.value = message
      emit({ source: 'doctor-call', event: 'error', diagnosisId: activeConfig.diagnosisId, message })
      throw new Error(message)
    }
  } else {
    await startVideo()
  }
}

async function close(): Promise<void> {
  if (!endNotified) await hangup()
  if (hangupNotification) await hangupNotification
  unsubscribeTranscriber()
  transcriptionGeneration += 1
  for (const pending of pendingTranscriptionStarts.values()) pending.resolve(false)
  for (const pending of pendingTranscriptionStops.values()) pending.resolve(false)
  pendingTranscriptionStarts.clear()
  pendingTranscriptionStops.clear()
  clearLiveCaptions()
  for (const pending of pendingLocalRecordingStarts.values()) pending.resolve(false)
  for (const pending of pendingLocalRecordingFinishes.values()) pending.resolve(false)
  pendingLocalRecordingStarts.clear()
  pendingLocalRecordingFinishes.clear()
  await cleanupLocalRecordingGraph()
  await logoutChat()
  activeConfig = null
  phase.value = 'ended'
}

window.doctorConsultation = {
  open,
  close,
  startVideo,
  hangup,
  hostCallReady,
  recordingResult,
  roomBindingResult,
  screenshotResult,
  transcriptionResult,
  localRecordingResult,
}
window.doctorCall = { start: open, hangup }
initializeQtWebChannel()

createApp(App, {
  phase: readonly(phase),
  statusText: readonly(statusText),
  patientName: readonly(patientName),
  mode: readonly(mode),
  messages: readonly(messages),
  chatReady: readonly(chatReady),
  chatBusy: readonly(chatBusy),
  notice: readonly(notice),
  hasMoreMessages: readonly(hasMoreMessages),
  transcriptionState: readonly(transcriptionState),
  localRecordingState: readonly(localRecordingState),
  liveCaptions: readonly(liveCaptions),
  onSendText: sendText,
  onSendAttachment: sendAttachment,
  onLoadMore: () => loadMessages(true),
  onReconnectChat: reconnectChat,
  onStartVideo: startVideo,
  onHangup: hangup,
  onSaveScreenshot: saveScreenshot,
}).mount('#app')

emit({ source: 'doctor-call', event: 'ready' })