blank/packages/stt-sdk-core/tests/compatibility/integration.test.ts

import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest'
import { SttSdk } from '../../src/core/stt-sdk'

// 模拟现有应用的使用模式
describe('Integration Test - Existing Application Pattern', () => {
  let sdk: SttSdk

  beforeEach(async () => {
    // 模拟现有应用的初始化过程
    sdk = new SttSdk()
    await sdk.initialize({
      appId: 'test-app-id',
      certificate: 'test-certificate',
      logLevel: 'info',
    })
  })

  afterEach(async () => {
    await sdk.destroy()
  })

  test('Should work with existing application initialization pattern', async () => {
    // 模拟现有应用的初始化流程
    const userId = 'test-user-123'
    const channel = 'test-channel-456'
    const userName = 'Test User'

    // 创建管理器实例
    const rtmManager = sdk.createRtmManager()
    const sttManager = sdk.createSttManager(rtmManager)

    // 初始化管理器（模拟现有应用的模式）
    await sttManager.init({
      userId,
      channel,
      userName,
    })

    // 验证管理器状态
    expect(sttManager.isInitialized).toBe(true)
    expect(sttManager.userId).toBe(userId)
    expect(sttManager.channel).toBe(channel)

    expect(rtmManager.isJoined).toBe(true)
    expect(rtmManager.userId).toBe(userId)
    expect(rtmManager.channel).toBe(channel)
  })

  test('Should handle transcription lifecycle like existing application', async () => {
    // 模拟现有应用的转录流程
    const rtmManager = sdk.createRtmManager()
    const sttManager = sdk.createSttManager(rtmManager)

    await sttManager.init({
      userId: 'test-user',
      channel: 'test-channel',
      userName: 'Test User',
    })

    // 开始转录（模拟现有应用的模式）
    const languages = [
      { source: 'en', target: ['zh'] },
      { source: 'zh', target: ['en'] },
    ]

    await sttManager.startTranscription({ languages })

    // 查询转录结果
    const result = await sttManager.queryTranscription()
    expect(result).toHaveProperty('status')
    expect(result).toHaveProperty('results')

    // 停止转录
    await sttManager.stopTranscription()
  })

  test('Should handle RTM operations like existing application', async () => {
    const rtmManager = sdk.createRtmManager()

    // RTM管理器需要先加入频道
    await rtmManager.join({
      channel: 'test-channel',
      userId: 'test-user',
      userName: 'Test User',
    })

    // 更新STT数据（模拟现有应用的模式）
    const sttData = {
      status: 'start',
      taskId: 'test-task-id',
      token: 'test-token',
      startTime: Date.now(),
      duration: 60000,
    }

    await rtmManager.updateSttData(sttData)

    // 更新语言设置
    const languages = [{ source: 'en', target: ['zh'] }]

    await rtmManager.updateLanguages(languages)

    // 锁操作
    await rtmManager.acquireLock()
    await rtmManager.releaseLock()
  })

  test('Should provide event system compatible with existing application', () => {
    // 模拟现有应用的事件监听模式
    const rtmManager = sdk.createRtmManager()
    const sttDataChangedHandler = vi.fn()
    const languagesChangedHandler = vi.fn()
    const errorHandler = vi.fn()

    // 监听事件（模拟现有应用的模式）
    rtmManager.on('metadataUpdated', sttDataChangedHandler)
    rtmManager.on('languagesUpdated', languagesChangedHandler)
    sdk.on('error', errorHandler)

    // 触发事件
    rtmManager.emit('metadataUpdated', { data: { status: 'start' } })
    rtmManager.emit('languagesUpdated', { languages: [] })
    sdk.emit('error', new Error('Test error'))

    // 验证事件处理
    expect(sttDataChangedHandler).toHaveBeenCalledWith({ data: { status: 'start' } })
    expect(languagesChangedHandler).toHaveBeenCalledWith({ languages: [] })
    expect(errorHandler).toHaveBeenCalledWith(expect.any(Error))

    // 移除事件监听
    rtmManager.off('metadataUpdated', sttDataChangedHandler)
    rtmManager.off('languagesUpdated', languagesChangedHandler)
    sdk.off('error', errorHandler)
  })

  test('Should handle destruction like existing application', async () => {
    // 模拟现有应用的销毁流程
    const rtmManager = sdk.createRtmManager()
    const sttManager = sdk.createSttManager(rtmManager)

    await sttManager.init({
      userId: 'test-user',
      channel: 'test-channel',
      userName: 'Test User',
    })

    // 销毁管理器（模拟现有应用的模式）
    await sttManager.destroy()
    await rtmManager.destroy()

    // 验证状态
    expect(sttManager.isInitialized).toBe(false)
    expect(rtmManager.isJoined).toBe(false)
  })

  test('Should maintain property access patterns from existing application', () => {
    // 模拟现有应用的属性访问模式
    const rtmManager = sdk.createRtmManager()
    const sttManager = sdk.createSttManager(rtmManager)

    // 直接属性访问（如 window.sttManager.userId）
    expect(typeof (sttManager as any).userId).toBe('string')
    expect(typeof (sttManager as any).channel).toBe('string')
    expect(typeof (sttManager as any).isInitialized).toBe('boolean')

    expect(typeof (rtmManager as any).userId).toBe('string')
    expect(typeof (rtmManager as any).channel).toBe('string')
    expect(typeof (rtmManager as any).isJoined).toBe('boolean')
    expect(Array.isArray((rtmManager as any).userList)).toBe(true)

    // 配置访问
    expect((sttManager as any).config).toBeUndefined() // 初始化前应为undefined
    expect((rtmManager as any).config).toBeUndefined()
  })

  test('Should handle error scenarios like existing application', async () => {
    // 测试错误处理兼容性
    const rtmManager = sdk.createRtmManager()
    const sttManager = sdk.createSttManager(rtmManager)

    // 未初始化时调用方法应该抛出错误
    await expect(sttManager.startTranscription({ languages: [] })).rejects.toThrow()

    await expect(rtmManager.updateSttData({})).rejects.toThrow()

    // 初始化后应该正常工作
    await sttManager.init({
      userId: 'test-user',
      channel: 'test-channel',
      userName: 'Test User',
    })

    // 现在应该可以正常工作（需要提供有效的语言）
    await expect(
      sttManager.startTranscription({ languages: [{ source: 'en', target: ['zh'] }] })
    ).resolves.toBeUndefined()

    await expect(rtmManager.updateSttData({ status: 'test' })).resolves.toBeUndefined()
  })
})