nl-um-vue-ts/src/composables/useWebRTC.ts

import { reactive, shallowRef, ref } from 'vue'
import flvjs from 'flv.js'
import * as messageApi from '@/api/modules/message'
import * as systemApi from '@/api/modules/system'
import * as callApi from '@/api/modules/call'
import { wsManager } from '@/api/websocket'
import { useToastStore } from '@/stores/toast'
import { useChatStore } from '@/stores/chat'
import { isRTMPMode } from '@/config/call'
import type { ChatMessage, Contact, ICEServerConfig } from '@/types/api'
import type { CallStatus } from '@/types/message'

export interface CallState {
  active: boolean
  minimized: boolean
  type: 'audio' | 'video'
  status: 'idle' | 'outgoing' | 'incoming' | 'connected'
  statusText: string
  id: string | null
  muted: boolean
  remoteMuted: boolean
  camOff: boolean
  remoteCamOff: boolean
  duration: number
  startTime: number | null
  // 小程序流信息
  miniprogramStreams: FlvStreamInfo[]
}

// FLV 流信息（来自小程序端）
export interface FlvStreamInfo {
  userId: string
  flvUrl: string
  player?: flvjs.Player
}

const RINGTONE_INCOMING_BASE64 = 'data:audio/mp3;base64,//uQxAAAAAAAAAAAAEluZm8AAAAPAAAAHgAABOYADQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NAAAAAAJDTEFtZTMuMTAwBK8AAAAAAAAAABQJAAHIAAAAHgAABObK82LdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//uQxAAAAAAABAAAAAAAAAAASbXAzLm9yZwAAAP8AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//uQxAEAMzI2hAAAAANIAAAAQAAAEAQGBAIAQBAEAQCBwAAAAe3/8w9///3v//+57//3///8w9///3v//+57//3///8AAKAAX/4EFwR//uQxBEAM8I2fAAAAANIAAAAQAAAEAAAAAAB///+BACAAAAAAH/9R//qD//6g////+oAAAD/4IHgAAAAAA//6gAAAAAT//uQxBIAOQI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxBsAOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxCsAOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxDQAOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxE4AOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxE4AOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxF4AOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxGwAOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxHgAOYI2fAAAAANIAAAAQAAAE//////////////////////////////////////////////////////////////////uQxIUAAANIAAAAAQAIAAAB//////////////////////////////////////////////////////////////////////////////////uQxIkAAANIAAAAAQAIAAAB////////////////////////////////////////////////////////////////////////////////'

export function useWebRTC(
    userId: string,
    onIncomingCall?: (senderUserId: string) => void,
    getRoomId?: (receiverUserId?: string) => string
) {
  const toastStore = useToastStore()
  const chatStore = useChatStore()

  const call = reactive<CallState>({
    active: false,
    minimized: false,
    type: 'video',
    status: 'idle',
    statusText: '',
    id: null,
    muted: false,
    remoteMuted: false,
    camOff: false,
    remoteCamOff: false,
    duration: 0,
    startTime: null,
    miniprogramStreams: [],
  })

  const isCaller = ref(false)
  const localStream = shallowRef<MediaStream | null>(null)
  const remoteStream = shallowRef<MediaStream | null>(null)
  let durationTimer: number | null = null
  let pc: RTCPeerConnection | null = null
  const pendingCandidates: RTCIceCandidate[] = []
  let currentReceiverUserId = ''
  let currentRoomId = ''

  // RTMP 模式相关
  let wsPushSocket: WebSocket | null = null
  let mediaRecorder: MediaRecorder | null = null
  const wsPushUrl = ref<string>('')

  const audioIncoming = new Audio(RINGTONE_INCOMING_BASE64)
  audioIncoming.loop = true

  // --- 信令处理 (修复版) ---
  async function handleSignaling(message: ChatMessage) {
    try {
      const content = message.content ? JSON.parse(message.content) : {}

      // 【关键修复】如果是群聊信令，直接忽略！
      // 通过判断是否存在 callRoomId 或 participantIds 来识别
      if (content.callRoomId || content.participantIds) {
        return
      }

      const signal = message.call_status as any
      const extra = message.extra ? (typeof message.extra === 'string' ? JSON.parse(message.extra) : message.extra) : {}

      if (extra.type) call.type = extra.type

      if (signal === 'sync_state') {
        if (content.action === 'cam-toggle') call.remoteCamOff = content.value
        else if (content.action === 'mic-toggle') call.remoteMuted = content.value
        return
      }

      if (signal === 'invite') {
        if (call.active) return
        isCaller.value = false
        currentReceiverUserId = message.sender_user_id
        if (message.room_id) currentRoomId = message.room_id
        call.id = message.call_id
        call.active = true
        call.minimized = false
        call.status = 'incoming'
        call.statusText = `邀请你通话`
        playRingtone('incoming')
        if (onIncomingCall) onIncomingCall(message.sender_user_id)

      } else if (signal === 'accepted') {
        stopRingtone()
        call.status = 'connected'
        call.statusText = '通话中'
        startCallTimer()
        // 加入房间获取小程序用户的 FLV 流地址（RTMP 模式下也会启动 WebSocket 推流）
        await joinCallRoomAndGetFlvUrls()
        
        // WebRTC 模式：创建 Offer
        if (!isRTMPMode()) {
          if (!pc) await createPC()
          const offer = await pc!.createOffer()
          await pc!.setLocalDescription(offer)
          sendSignal('offer', offer)
        }

      } else if (signal === 'offer') {
        // WebRTC 模式才处理 offer
        if (!isRTMPMode()) {
          stopRingtone()
          if (!pc) {
            await initMedia(call.type === 'video')
            await createPC()
          }
          await pc!.setRemoteDescription(content)
          processPendingCandidates()
          const answer = await pc!.createAnswer()
          await pc!.setLocalDescription(answer)
          sendSignal('answer', answer, message.sender_user_id)
          call.status = 'connected'
          call.statusText = '通话中'
          startCallTimer()
        }

      } else if (signal === 'answer') {
        // WebRTC 模式才处理 answer
        if (!isRTMPMode() && pc) {
          await pc.setRemoteDescription(content)
          processPendingCandidates()
        }

      } else if (signal === 'candidate') {
        // WebRTC 模式才处理 candidate
        if (!isRTMPMode()) {
          if (pc && pc.remoteDescription) await pc.addIceCandidate(content)
          else pendingCandidates.push(content)
        }

      } else if (['hangup', 'ended', 'answered_elsewhere'].includes(signal)) {
        if (isCaller.value) {
          if (call.status === 'outgoing') sendSummaryMessage('rejected')
          else if (call.status === 'connected') sendSummaryMessage('connected')
        }
        closeCall()
        if (signal === 'answered_elsewhere') toastStore.info('已在其他设备接听')
      }
    } catch (error) {
      console.error('Error handling signaling:', error)
    }
  }

  // ... (其余辅助函数保持不变，为节省篇幅只展示关键变动，但你需要完整代码，下面补充完整辅助函数) ...

  function playRingtone(type: 'incoming' | 'dialing') {
    stopRingtone()
    const playPromise = audioIncoming.play()
    if (playPromise !== undefined) playPromise.catch(e => {})
  }

  function stopRingtone() {
    audioIncoming.pause()
    audioIncoming.currentTime = 0
  }

  function getSafeRoomId(targetUserId?: string): string | null {
    if (currentRoomId) return currentRoomId
    if (targetUserId && getRoomId) {
      const rid = getRoomId(targetUserId)
      if (rid) return rid
    }
    if (targetUserId && userId) {
      return [userId, targetUserId].sort().join('_')
    }
    return null
  }

  async function sendSummaryMessage(reason: 'connected' | 'cancelled' | 'rejected' | 'busy') {
    const roomId = getSafeRoomId(currentReceiverUserId)
    if (!roomId) return

    // 通话类型说明
    const callTypeText = call.type === 'video' ? '[视频通话]' : '[语音通话]'

    // 根据原因生成系统消息内容
    let content = ''
    switch (reason) {
      case 'connected':
        content = `${callTypeText} 通话时长 ${formatDuration(call.duration)}`
        break
      case 'cancelled':
        content = `${callTypeText} 已取消`
        break
      case 'rejected':
        content = `${callTypeText} 对方未接听`
        break
      case 'busy':
        content = `${callTypeText} 对方忙`
        break
    }

    // 构造通话结果的 extra 数据
    const extraData = {
      call_type: call.type,
      call_reason: reason,
      call_duration: call.duration,
      call_id: call.id
    }

    try {
      // 发送系统消息 (message_type = 4)
      const payload = {
        sender_client_id: wsManager.getClientId() || '',
        receiver_user_id: currentReceiverUserId,
        room_id: roomId,
        message_type: 4, // 系统消息
        content: content,
        extra: JSON.stringify(extraData)
      }
      await messageApi.sendMessage(payload)

      // 同时添加到本地消息列表
      const systemMessage: ChatMessage = {
        id: Date.now(),
        room_id: roomId,
        sender_user_id: userId,
        message_type: 4,
        content: content,
        extra: extraData,
        created_at: new Date().toISOString(),
        updated_at: new Date().toISOString()
      }
      chatStore.addMessage(roomId, systemMessage)
    } catch (error) {
      console.error('发送通话结束消息失败:', error)
    }
  }

  // ICE 服务器缓存
  let cachedIceServers: RTCIceServer[] | null = null

  /**
   * 获取 ICE 服务器配置（优先从后端 API 获取，失败时使用备用配置）
   */
  async function getIceServers(): Promise<RTCIceServer[]> {
    // 如果已有缓存，直接使用
    if (cachedIceServers) {
      return cachedIceServers
    }

    try {
      const servers = await systemApi.getIceServers(userId)
      if (servers && servers.length > 0) {
        // 转换为 RTCIceServer 格式
        cachedIceServers = servers.map((s: ICEServerConfig) => ({
          urls: s.urls,
          username: s.username,
          credential: s.credential
        }))
        return cachedIceServers
      }
    } catch (error) {
      console.warn('获取 ICE 服务器配置失败，使用备用配置:', error)
    }

    // 备用配置：公共 STUN 服务器
    cachedIceServers = [
      { urls: 'stun:stun.l.google.com:19302' },
      { urls: 'stun:stun1.l.google.com:19302' }
    ]
    return cachedIceServers
  }

  // --- WebRTC ---
  async function initMedia(videoEnabled: boolean): Promise<void> {
    try {
      if (localStream.value) {
        localStream.value.getTracks().forEach(t => t.stop())
        localStream.value = null
      }
      const constraints: MediaStreamConstraints = {
        video: videoEnabled ? { width: { ideal: 640 }, height: { ideal: 480 } } : false,
        audio: { echoCancellation: true, noiseSuppression: true },
      }
      const stream = await navigator.mediaDevices.getUserMedia(constraints)
      localStream.value = stream
    } catch (error: any) {
      throw new Error('无法获取设备权限')
    }
  }

  async function createPC(): Promise<void> {
    const iceServers = await getIceServers()
    if (pc) { pc.close(); pc = null }
    pc = new RTCPeerConnection({ iceServers })

    pc.oniceconnectionstatechange = () => {
      if (pc?.iceConnectionState === 'failed') {
        call.statusText = '连接失败'
        endCall()
      } else if (pc?.iceConnectionState === 'connected') {
        call.statusText = '通话中'
      }
    }

    if (localStream.value) {
      localStream.value.getTracks().forEach((track) => pc!.addTrack(track, localStream.value!))
    }

    pc.ontrack = (e) => {
      if (e.streams && e.streams[0]) {
        remoteStream.value = e.streams[0]
      }
    }

    pc.onicecandidate = (e) => {
      if (e.candidate && call.id) sendSignal('candidate', e.candidate)
    }
  }

  function sendSignal(status: CallStatus, data?: any, receiverUserId?: string) {
    if (!call.id) return
    const targetUserId = receiverUserId || currentReceiverUserId
    const roomId = getSafeRoomId(targetUserId)
    if (!roomId) return
    const payload = {
      sender_client_id: wsManager.getClientId() || '',
      receiver_user_id: targetUserId,
      room_id: roomId,
      message_type: 6,
      content: JSON.stringify(data || {}),
      call_id: call.id,
      call_status: status,
      extra: JSON.stringify({ type: call.type }),
    }
    messageApi.sendMessage(payload).catch(console.error)
  }

  function sendSyncState(type: 'cam-toggle' | 'mic-toggle', value: boolean) {
    if (call.status !== 'connected') return
    const roomId = getSafeRoomId(currentReceiverUserId)
    if (!roomId) return
    const payload = {
      sender_client_id: wsManager.getClientId() || '',
      receiver_user_id: currentReceiverUserId,
      room_id: roomId,
      message_type: 6,
      content: JSON.stringify({ action: type, value }),
      call_id: call.id,
      call_status: 'sync_state' as any,
      extra: JSON.stringify({ type: call.type })
    }
    messageApi.sendMessage(payload).catch(console.error)
  }

  async function startCall(type: 'audio' | 'video', receiverUserId: string, roomId?: string, contact?: Contact) {
    if (roomId) currentRoomId = roomId
    else if (contact?.room_id) currentRoomId = contact.room_id
    else if (getRoomId) {
      const found = getRoomId(receiverUserId)
      if (found) currentRoomId = found
    }

    if (!currentRoomId) {
      toastStore.error('无法建立通话连接：缺少房间信息')
      return false
    }

    isCaller.value = true
    currentReceiverUserId = receiverUserId
    call.type = type
    call.id = Date.now().toString()
    call.active = true
    call.minimized = false
    call.status = 'outgoing'
    call.statusText = '正在呼叫...'
    call.duration = 0
    call.camOff = false
    call.remoteCamOff = false
    call.remoteMuted = false
    remoteStream.value = null

    try {
      await initMedia(type === 'video')
      
      // 根据模式选择不同的推流方式
      if (isRTMPMode()) {
        console.log('[WebRTC] 使用 RTMP 模式')
        // RTMP 模式：加入房间后会自动开始 WebSocket 推流
      } else {
        console.log('[WebRTC] 使用 WebRTC 模式')
        await createPC()
      }
      
      playRingtone('dialing')
      sendSignal('invite', undefined, receiverUserId)
      return true
    } catch (error: any) {
      toastStore.error(error.message || '无法启动通话')
      closeCall()
      return false
    }
  }

  async function acceptCall(senderUserId?: string) {
    isCaller.value = false
    stopRingtone()
    if (senderUserId) currentReceiverUserId = senderUserId
    call.status = 'connected'
    call.statusText = '正在连接...'
    call.camOff = false
    call.remoteCamOff = false

    try {
      await initMedia(call.type === 'video')
      
      // 根据模式选择不同的推流方式
      if (isRTMPMode()) {
        console.log('[WebRTC] 接听：使用 RTMP 模式')
        // RTMP 模式：加入房间后会自动开始 WebSocket 推流
        await joinCallRoomAndGetFlvUrls()
      } else {
        console.log('[WebRTC] 接听：使用 WebRTC 模式')
        await createPC()
      }
      
      sendSignal('accepted', undefined, currentReceiverUserId)
    } catch (error) {
      endCall()
    }
  }

  function endCall() {
    stopRingtone()
    // 只有发起方发送通话结束系统消息，避免重复
    if (isCaller.value) {
      if (call.status === 'outgoing') {
        sendSummaryMessage('cancelled') // 呼出状态主动取消
      } else if (call.status === 'connected') {
        sendSummaryMessage('connected') // 通话中主动挂断
      }
    }
    // 被叫方不发送消息，由发起方统一发送
    sendSignal('hangup')
    // 离开通话房间
    leaveCallRoom()
    closeCall()
  }

  function closeCall() {
    stopRingtone()
    currentRoomId = ''
    call.active = false
    call.status = 'idle'
    call.statusText = ''
    call.id = null
    stopCallTimer()
    
    // 停止 WebSocket 推流 (RTMP 模式)
    stopWebSocketPush()
    
    if (pc) {
      pc.close()
      pc = null
    }
    if (localStream.value) {
      localStream.value.getTracks().forEach(t => t.stop())
      localStream.value = null
    }
    remoteStream.value = null
    // 清理 FLV 播放器
    destroyFlvPlayers()
    call.miniprogramStreams = []
  }

  /**
   * 加入通话房间并获取小程序用户的 FLV 流地址
   */
  async function joinCallRoomAndGetFlvUrls(): Promise<void> {
    if (!currentRoomId) return

    try {
      const response = await callApi.joinCallRoom({
        room_id: currentRoomId,
        user_id: userId,
        platform: 'h5'
      })

      console.log('[WebRTC] 加入房间响应:', response)

      // 检查是否有小程序用户的 FLV 流
      if (response.flv_pull_urls && response.flv_pull_urls.length > 0) {
        console.log('[WebRTC] 检测到小程序用户流:', response.flv_pull_urls)
        call.miniprogramStreams = response.flv_pull_urls.map(p => ({
          userId: p.user_id,
          flvUrl: p.flv_url || ''
        })).filter(s => s.flvUrl)
      }

      // RTMP 模式：获取 WebSocket 推流地址并开始推流
      if (isRTMPMode() && response.ws_push_url) {
        wsPushUrl.value = response.ws_push_url
        console.log('[WebRTC] RTMP模式，WebSocket推流地址:', response.ws_push_url)
        // 开始 WebSocket 推流
        if (localStream.value) {
          startWebSocketPush(response.ws_push_url)
        }
      }
    } catch (error) {
      console.error('[WebRTC] 加入房间失败:', error)
    }
  }

  /**
   * 开始 WebSocket 推流 (RTMP 模式)
   * 使用 MediaRecorder 编码本地流，通过 WebSocket 发送到服务器
   */
  function startWebSocketPush(wsUrl: string): void {
    if (!localStream.value) {
      console.error('[WebRTC] 无法推流：本地流不存在')
      return
    }

    // 关闭已有连接
    stopWebSocketPush()

    console.log('[WebRTC] 开始 WebSocket 推流:', wsUrl)

    // 创建 WebSocket 连接
    wsPushSocket = new WebSocket(wsUrl)

    wsPushSocket.onopen = () => {
      console.log('[WebRTC] WebSocket 连接已建立')
      // 连接成功后开始录制
      startMediaRecorder()
    }

    wsPushSocket.onclose = (event) => {
      console.log('[WebRTC] WebSocket 连接已关闭:', event.code, event.reason)
    }

    wsPushSocket.onerror = (error) => {
      console.error('[WebRTC] WebSocket 错误:', error)
      toastStore.error('推流连接失败')
    }

    wsPushSocket.onmessage = (event) => {
      // 处理服务器消息（如有需要）
      console.log('[WebRTC] WebSocket 收到消息:', event.data)
    }
  }

  /**
   * 开始 MediaRecorder 录制
   */
  function startMediaRecorder(): void {
    if (!localStream.value || !wsPushSocket) {
      return
    }

    // 检查浏览器支持的 MIME 类型
    const mimeTypes = [
      'video/webm;codecs=vp8,opus',
      'video/webm;codecs=vp9,opus',
      'video/webm;codecs=h264,opus',
      'video/webm',
    ]

    let selectedMimeType = ''
    for (const mimeType of mimeTypes) {
      if (MediaRecorder.isTypeSupported(mimeType)) {
        selectedMimeType = mimeType
        break
      }
    }

    if (!selectedMimeType) {
      console.error('[WebRTC] 浏览器不支持 WebM 录制')
      toastStore.error('您的浏览器不支持视频推流')
      return
    }

    console.log('[WebRTC] 使用编码格式:', selectedMimeType)

    try {
      mediaRecorder = new MediaRecorder(localStream.value, {
        mimeType: selectedMimeType,
        videoBitsPerSecond: 500000, // 500kbps
        audioBitsPerSecond: 64000,  // 64kbps
      })

      mediaRecorder.ondataavailable = (event) => {
        if (event.data.size > 0 && wsPushSocket?.readyState === WebSocket.OPEN) {
          wsPushSocket.send(event.data)
        }
      }

      mediaRecorder.onerror = (error) => {
        console.error('[WebRTC] MediaRecorder 错误:', error)
      }

      mediaRecorder.onstart = () => {
        console.log('[WebRTC] MediaRecorder 开始录制')
      }

      mediaRecorder.onstop = () => {
        console.log('[WebRTC] MediaRecorder 停止录制')
      }

      // 每 100ms 发送一次数据
      mediaRecorder.start(100)

    } catch (error) {
      console.error('[WebRTC] 创建 MediaRecorder 失败:', error)
      toastStore.error('初始化推流失败')
    }
  }

  /**
   * 停止 WebSocket 推流
   */
  function stopWebSocketPush(): void {
    // 停止 MediaRecorder
    if (mediaRecorder) {
      try {
        if (mediaRecorder.state !== 'inactive') {
          mediaRecorder.stop()
        }
      } catch (e) {
        // 忽略错误
      }
      mediaRecorder = null
    }

    // 关闭 WebSocket
    if (wsPushSocket) {
      try {
        wsPushSocket.close()
      } catch (e) {
        // 忽略错误
      }
      wsPushSocket = null
    }

    wsPushUrl.value = ''
    console.log('[WebRTC] WebSocket 推流已停止')
  }

  /**
   * 离开通话房间
   */
  async function leaveCallRoom(): Promise<void> {
    if (!currentRoomId) return

    try {
      await callApi.leaveCallRoom({
        room_id: currentRoomId,
        user_id: userId
      })
    } catch (error) {
      console.error('[WebRTC] 离开房间失败:', error)
    }
  }

  /**
   * 初始化 FLV 播放器
   * @param videoElement 视频元素
   * @param streamIndex 流索引
   */
  function initFlvPlayer(videoElement: HTMLVideoElement, streamIndex: number = 0): flvjs.Player | null {
    if (!flvjs.isSupported()) {
      console.error('[WebRTC] 浏览器不支持 flv.js')
      toastStore.error('您的浏览器不支持 FLV 播放')
      return null
    }

    const stream = call.miniprogramStreams[streamIndex]
    if (!stream || !stream.flvUrl) {
      console.error('[WebRTC] 没有可用的 FLV 流')
      return null
    }

    // 如果已有播放器，先销毁
    if (stream.player) {
      stream.player.destroy()
    }

    console.log('[WebRTC] 初始化 FLV 播放器:', stream.flvUrl)

    const player = flvjs.createPlayer({
      type: 'flv',
      url: stream.flvUrl,
      isLive: true,
      hasAudio: true,
      hasVideo: true,
    }, {
      enableWorker: false,
      enableStashBuffer: false,
      stashInitialSize: 128,
      lazyLoad: false,
    })

    player.attachMediaElement(videoElement)
    player.load()
    player.play()

    // 监听错误
    player.on(flvjs.Events.ERROR, (errorType, errorDetail) => {
      console.error('[WebRTC] FLV 播放错误:', errorType, errorDetail)
      if (errorType === flvjs.ErrorTypes.NETWORK_ERROR) {
        toastStore.error('网络错误，无法播放小程序视频流')
      }
    })

    // 保存播放器引用
    stream.player = player

    return player
  }

  /**
   * 销毁所有 FLV 播放器
   */
  function destroyFlvPlayers(): void {
    for (const stream of call.miniprogramStreams) {
      if (stream.player) {
        try {
          stream.player.pause()
          stream.player.unload()
          stream.player.detachMediaElement()
          stream.player.destroy()
        } catch (e) {
          console.error('[WebRTC] 销毁 FLV 播放器失败:', e)
        }
        stream.player = undefined
      }
    }
  }

  /**
   * 检查是否有小程序流需要播放
   */
  function hasMiniprogramStreams(): boolean {
    return call.miniprogramStreams.length > 0
  }

  async function processPendingCandidates() {
    while (pendingCandidates.length > 0) {
      const c = pendingCandidates.shift()
      if (c && pc) await pc.addIceCandidate(c).catch(e => {})
    }
  }

  function startCallTimer() {
    stopCallTimer()
    call.startTime = Date.now()
    durationTimer = window.setInterval(() => {
      if (call.startTime) call.duration = Math.floor((Date.now() - call.startTime) / 1000)
    }, 1000)
  }

  function stopCallTimer() {
    if (durationTimer) { clearInterval(durationTimer); durationTimer = null }
    call.startTime = null
    call.duration = 0
  }

  function formatDuration(seconds: number): string {
    const m = Math.floor(seconds / 60).toString().padStart(2, '0')
    const s = (seconds % 60).toString().padStart(2, '0')
    const h = Math.floor(seconds / 3600)
    return h > 0 ? `${h.toString().padStart(2, '0')}:${m}:${s}` : `${m}:${s}`
  }

  function toggleMute() {
    call.muted = !call.muted
    sendSyncState('mic-toggle', call.muted)
    if (localStream.value) localStream.value.getAudioTracks().forEach(t => t.enabled = !call.muted)
  }

  function toggleCamera() {
    call.camOff = !call.camOff
    sendSyncState('cam-toggle', call.camOff)
    if (localStream.value) localStream.value.getVideoTracks().forEach(t => t.enabled = !call.camOff)
  }

  return {
    call,
    localStream,
    remoteStream,
    startCall,
    acceptCall,
    endCall,
    handleSignaling,
    toggleMute,
    toggleCamera,
    formatDuration,
    // FLV 播放相关（用于小程序流）
    initFlvPlayer,
    destroyFlvPlayers,
    hasMiniprogramStreams,
  }
}