import { reactive } from 'vue'
import type { WindowService } from './WindowService'
import type { ResourceService } from './ResourceService'
import type { EventCommunicationService } from './EventCommunicationService'
import type { ApplicationSandboxEngine } from './ApplicationSandboxEngine'
import { v4 as uuidv4 } from 'uuid'
import { externalAppDiscovery } from './ExternalAppDiscovery'

/**
 * 应用状态枚举
 */
export enum AppLifecycleState {
  INSTALLING = 'installing',
  INSTALLED = 'installed',
  STARTING = 'starting',
  RUNNING = 'running',
  SUSPENDED = 'suspended',
  STOPPING = 'stopping',
  STOPPED = 'stopped',
  UNINSTALLING = 'uninstalling',
  ERROR = 'error',
  CRASHED = 'crashed',
  AVAILABLE = 'available', // 外置应用可用但未注册状态
}

/**
 * 应用清单文件接口
 */
export interface AppManifest {
  id: string
  name: string
  version: string
  description: string
  author: string
  homepage?: string
  icon: string
  entryPoint: string // 入口文件路径
  permissions: string[]
  minSystemVersion?: string
  dependencies?: Record<string, string>
  window?: {
    width: number
    height: number
    minWidth?: number
    minHeight?: number
    maxWidth?: number
    maxHeight?: number
    resizable?: boolean
    center?: boolean
  }
  background?: {
    persistent?: boolean
    scripts?: string[]
  }
  contentSecurity?: {
    policy?: string
    allowedDomains?: string[]
  }
}

/**
 * 应用实例接口
 */
export interface AppInstance {
  id: string
  manifest: AppManifest
  state: AppLifecycleState
  windowId?: string
  sandboxId?: string
  processId: string
  installedAt: Date
  startedAt?: Date
  lastActiveAt?: Date
  stoppedAt?: Date
  errorCount: number
  crashCount: number
  memoryUsage: number
  cpuUsage: number
  version: string
  autoStart: boolean
  persistent: boolean
}

/**
 * 应用安装包接口
 */
export interface AppPackage {
  manifest: AppManifest
  files: Map<string, Blob | string> // 文件路径到内容的映射
  signature?: string // 数字签名
  checksum: string // 校验和
}

/**
 * 应用启动选项
 */
export interface AppStartOptions {
  windowConfig?: {
    x?: number
    y?: number
    width?: number
    height?: number
    state?: 'normal' | 'minimized' | 'maximized'
  }
  args?: Record<string, any>
  background?: boolean
}

/**
 * 应用生命周期事件
 */
export interface AppLifecycleEvents {
  onInstalled: (appId: string, manifest: AppManifest) => void
  onUninstalled: (appId: string) => void
  onStarted: (appId: string, processId: string) => void
  onStopped: (appId: string, processId: string) => void
  onSuspended: (appId: string, processId: string) => void
  onResumed: (appId: string, processId: string) => void
  onError: (appId: string, error: Error) => void
  onCrashed: (appId: string, reason: string) => void
  onStateChanged: (appId: string, newState: AppLifecycleState, oldState: AppLifecycleState) => void
}

/**
 * 应用生命周期管理器
 */
export class ApplicationLifecycleManager {
  private installedApps = reactive(new Map<string, AppInstance>())
  private runningProcesses = reactive(new Map<string, AppInstance>())
  private appFiles = new Map<string, Map<string, Blob | string>>() // 应用文件存储

  private windowService: WindowService
  private resourceService: ResourceService
  private eventService: EventCommunicationService
  private sandboxEngine: ApplicationSandboxEngine

  constructor(
    windowService: WindowService,
    resourceService: ResourceService,
    eventService: EventCommunicationService,
    sandboxEngine: ApplicationSandboxEngine,
  ) {
    this.windowService = windowService
    this.resourceService = resourceService
    this.eventService = eventService
    this.sandboxEngine = sandboxEngine

    this.setupEventListeners()
    this.loadInstalledApps()
    // 外部应用发现已由 SystemServiceIntegration 统一管理，无需重复初始化
  }

  /**
   * 安装应用
   */
  async installApp(appPackage: AppPackage): Promise<string> {
    const { manifest, files, checksum } = appPackage
    const appId = manifest.id

    try {
      // 检查应用是否已安装
      if (this.installedApps.has(appId)) {
        throw new Error(`应用 ${appId} 已安装`)
      }

      // 验证清单文件
      this.validateManifest(manifest)

      // 验证校验和
      if (!this.verifyChecksum(files, checksum)) {
        throw new Error('应用包校验失败')
      }

      // 检查权限
      await this.checkPermissions(manifest.permissions)

      const now = new Date()
      const appInstance: AppInstance = {
        id: appId,
        manifest,
        state: AppLifecycleState.INSTALLING,
        processId: '',
        installedAt: now,
        errorCount: 0,
        crashCount: 0,
        memoryUsage: 0,
        cpuUsage: 0,
        version: manifest.version,
        autoStart: false,
        persistent: manifest.background?.persistent || false,
      }

      // 更新状态
      this.updateAppState(appInstance, AppLifecycleState.INSTALLING)
      this.installedApps.set(appId, appInstance)

      // 存储应用文件
      this.appFiles.set(appId, files)

      // 保存到本地存储
      await this.saveAppToStorage(appInstance)

      // 更新状态为已安装
      this.updateAppState(appInstance, AppLifecycleState.INSTALLED)

      this.eventService.sendMessage('system', 'app-lifecycle', {
        type: 'installed',
        appId,
        manifest,
      })

      console.log(`应用 ${manifest.name} (${appId}) 安装成功`)
      return appId
    } catch (error) {
      // 清理安装失败的应用
      this.installedApps.delete(appId)
      this.appFiles.delete(appId)

      console.error('应用安装失败:', error)
      throw error
    }
  }

  /**
   * 卸载应用
   */
  async uninstallApp(appId: string): Promise<boolean> {
    const app = this.installedApps.get(appId)
    if (!app) {
      throw new Error(`应用 ${appId} 未安装`)
    }

    try {
      // 如果应用正在运行，先停止
      if (app.state === AppLifecycleState.RUNNING || app.state === AppLifecycleState.SUSPENDED) {
        await this.stopApp(appId)
      }

      this.updateAppState(app, AppLifecycleState.UNINSTALLING)

      // 清理应用数据
      await this.resourceService.clearStorage(appId)
      await this.resourceService.revokeAllPermissions(appId)

      // 删除应用文件
      this.appFiles.delete(appId)

      // 从存储中删除
      await this.removeAppFromStorage(appId)

      // 从已安装列表中移除
      this.installedApps.delete(appId)

      this.eventService.sendMessage('system', 'app-lifecycle', {
        type: 'uninstalled',
        appId,
      })

      console.log(`应用 ${appId} 卸载成功`)
      return true
    } catch (error) {
      console.error('应用卸载失败:', error)
      throw error
    }
  }

  /**
   * 启动应用
   */
  async startApp(appId: string, options: AppStartOptions = {}): Promise<string> {
    let app = this.installedApps.get(appId)

    // 如果应用未安装，检查是否为外置应用
    let isExternalApp = false
    if (!app) {
      const externalApp = externalAppDiscovery.getApp(appId)
      if (externalApp) {
        console.log(`[LifecycleManager] 发现外置应用 ${appId}`)
        isExternalApp = true
        
        // 为外部应用创建临时实例
        const now = new Date()
        app = {
          id: externalApp.manifest.id,
          manifest: externalApp.manifest,
          state: AppLifecycleState.INSTALLED,
          processId: '',
          installedAt: now,
          errorCount: 0,
          crashCount: 0,
          memoryUsage: 0,
          cpuUsage: 0,
          version: externalApp.manifest.version,
          autoStart: false,
          persistent: false,
        }
      }
    }

    if (!app) {
      throw new Error(`应用 ${appId} 未安装且未发现`)
    }

    if (app.state === AppLifecycleState.RUNNING) {
      throw new Error(`应用 ${appId} 已在运行`)
    }

    try {
      const processId = uuidv4()
      app.processId = processId

      this.updateAppState(app, AppLifecycleState.STARTING)

      // 检查是否为内置应用
      let isBuiltInApp = false

      try {
        const { AppRegistry } = await import('../apps/AppRegistry')
        const appRegistry = AppRegistry.getInstance()
        isBuiltInApp = appRegistry.hasApp(appId)
      } catch (error) {
        console.warn('无法导入 AppRegistry')
      }

      // 检查是否为外置应用（仅当不是内置应用时）
      // 修复：移除重复的变量声明，使用已声明的isExternalApp变量
      if (!isBuiltInApp && !isExternalApp) {
        isExternalApp = externalAppDiscovery.hasApp(appId)
      }

      // 创建窗体（如果不是后台应用）
      let windowId: string | undefined
      if (!options.background && !app.manifest.background?.scripts) {
        const windowConfig = {
          title: app.manifest.name,
          width: options.windowConfig?.width || app.manifest.window?.width || 800,
          height: options.windowConfig?.height || app.manifest.window?.height || 600,
          x: options.windowConfig?.x,
          y: options.windowConfig?.y,
          resizable: app.manifest.window?.resizable !== false,
          minWidth: app.manifest.window?.minWidth,
          minHeight: app.manifest.window?.minHeight,
          maxWidth: app.manifest.window?.maxWidth,
          maxHeight: app.manifest.window?.maxHeight,
        }

        const windowInstance = await this.windowService.createWindow(appId, windowConfig)
        windowId = windowInstance.id
        app.windowId = windowId

        // 对于内置应用，需要在窗口内容区域挂载 AppRenderer 组件
        if (isBuiltInApp) {
          await this.mountBuiltInApp(appId, windowInstance)
        }

        // 对于内置应用，不需要等待窗口DOM元素渲染
        if (!isBuiltInApp) {
          // 稍等片刻确保窗口DOM元素已经渲染完成
          await new Promise((resolve) => setTimeout(resolve, 100))
        }
      }

      // 对于外置应用，需要创建沙箱；内置应用跳过沙箱
      if (isExternalApp && !isBuiltInApp) {
        // 为外置应用创建沙箱
        const sandboxConfig = {
          securityLevel: 2, // HIGH
          allowScripts: true,
          allowSameOrigin: false, // 安全考虑：不允许同源访问以防止沙箱逃逸
          allowForms: true,
          networkTimeout: 15000, // 增加超时时间到15秒
          csp:
            app.manifest.contentSecurity?.policy ||
            "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; connect-src 'self';",
        }

        const sandbox = await this.sandboxEngine.createSandbox(
          appId,
          windowId || 'background',
          sandboxConfig,
        )
        app.sandboxId = sandbox.id

        // 为外置应用加载代码
        await this.loadExternalAppInSandbox(app, sandbox.id)
      } else if (isBuiltInApp) {
        console.log(`[LifecycleManager] 内置应用 ${appId} 跳过沙箱创建和代码加载`)
      } else {
        console.warn(`[LifecycleManager] 未知应用类型: ${appId}`)
      }

      // 更新状态
      const now = new Date()
      app.startedAt = now
      app.lastActiveAt = now
      this.updateAppState(app, AppLifecycleState.RUNNING)

      // 添加到运行进程列表
      this.runningProcesses.set(processId, app)

      // 注意：状态变更消息由updateAppState方法自动发送，不需要手动发送

      console.log(`应用 ${app.manifest.name} (${appId}) 启动成功，进程ID: ${processId}`)
      return processId
    } catch (error) {
      this.updateAppState(app, AppLifecycleState.ERROR)
      app.errorCount++

      console.error('应用启动失败:', error)
      throw error
    }
  }

  /**
   * 停止应用
   */
  async stopApp(appId: string): Promise<boolean> {
    // 首先从已安装应用中查找
    let app = this.installedApps.get(appId)
    
    // 如果未找到，从运行进程列表中查找（可能是外部应用的临时实例）
    if (!app) {
      for (const runningApp of this.runningProcesses.values()) {
        if (runningApp.id === appId) {
          app = runningApp
          break
        }
      }
    }
    
    if (!app) {
      throw new Error(`应用 ${appId} 未安装或未运行`)
    }

    if (app.state !== AppLifecycleState.RUNNING && app.state !== AppLifecycleState.SUSPENDED) {
      return true
    }

    try {
      this.updateAppState(app, AppLifecycleState.STOPPING)

      // 销毁沙箱
      if (app.sandboxId) {
        this.sandboxEngine.destroySandbox(app.sandboxId)
        app.sandboxId = undefined
      }

      // 关闭窗体（如果还存在）
      if (app.windowId) {
        const window = this.windowService.getWindow(app.windowId)
        if (window) {
          await this.windowService.destroyWindow(app.windowId)
        }
        app.windowId = undefined
      }

      // 更新状态
      app.stoppedAt = new Date()
      this.updateAppState(app, AppLifecycleState.STOPPED)

      // 从运行进程列表中移除
      if (app.processId) {
        this.runningProcesses.delete(app.processId)
        app.processId = ''
      }

      // 注意：状态变更消息由updateAppState方法自动发送，不需要手动发送

      console.log(`应用 ${appId} 停止成功`)
      return true
    } catch (error) {
      console.error('应用停止失败:', error)
      return false
    }
  }

  /**
   * 暂停应用
   */
  async suspendApp(appId: string): Promise<boolean> {
    // 首先从已安装应用中查找
    let app = this.installedApps.get(appId)
    
    // 如果未找到，从运行进程列表中查找（可能是外部应用的临时实例）
    if (!app) {
      for (const runningApp of this.runningProcesses.values()) {
        if (runningApp.id === appId) {
          app = runningApp
          break
        }
      }
    }
    
    if (!app || app.state !== AppLifecycleState.RUNNING) {
      return false
    }

    try {
      // 暂停沙箱
      if (app.sandboxId) {
        this.sandboxEngine.suspendSandbox(app.sandboxId)
      }

      // 最小化窗体
      if (app.windowId) {
        this.windowService.minimizeWindow(app.windowId)
      }

      this.updateAppState(app, AppLifecycleState.SUSPENDED)

      // 注意：状态变更消息由updateAppState方法自动发送，不需要手动发送

      console.log(`应用 ${appId} 已暂停`)
      return true
    } catch (error) {
      console.error('应用暂停失败:', error)
      return false
    }
  }

  /**
   * 恢复应用
   */
  async resumeApp(appId: string): Promise<boolean> {
    // 首先从已安装应用中查找
    let app = this.installedApps.get(appId)
    
    // 如果未找到，从运行进程列表中查找（可能是外部应用的临时实例）
    if (!app) {
      for (const runningApp of this.runningProcesses.values()) {
        if (runningApp.id === appId) {
          app = runningApp
          break
        }
      }
    }
    
    if (!app || app.state !== AppLifecycleState.SUSPENDED) {
      return false
    }

    try {
      // 恢复沙箱
      if (app.sandboxId) {
        this.sandboxEngine.resumeSandbox(app.sandboxId)
      }

      // 恢复窗体
      if (app.windowId) {
        this.windowService.restoreWindow(app.windowId)
      }

      app.lastActiveAt = new Date()
      this.updateAppState(app, AppLifecycleState.RUNNING)

      // 注意：状态变更消息由updateAppState方法自动发送，不需要手动发送

      console.log(`应用 ${appId} 已恢复`)
      return true
    } catch (error) {
      console.error('应用恢复失败:', error)
      return false
    }
  }

  /**
   * 重启应用
   */
  async restartApp(appId: string, options?: AppStartOptions): Promise<string> {
    await this.stopApp(appId)
    // 等待一小段时间确保完全停止
    await new Promise((resolve) => setTimeout(resolve, 1000))
    return this.startApp(appId, options)
  }

  /**
   * 获取应用信息
   */
  getApp(appId: string): AppInstance | undefined {
    return this.installedApps.get(appId)
  }

  /**
   * 获取所有已安装应用
   */
  getAllApps(): AppInstance[] {
    return Array.from(this.installedApps.values())
  }

  /**
   * 获取正在运行的应用
   */
  getRunningApps(): AppInstance[] {
    return Array.from(this.runningProcesses.values())
  }

  /**
   * 检查应用是否正在运行
   */
  isAppRunning(appId: string): boolean {
    // 首先从已安装应用中查找
    let app = this.installedApps.get(appId)
    
    // 如果未找到，从运行进程列表中查找（可能是外部应用的临时实例）
    if (!app) {
      for (const runningApp of this.runningProcesses.values()) {
        if (runningApp.id === appId) {
          app = runningApp
          break
        }
      }
    }
    
    return app?.state === AppLifecycleState.RUNNING || app?.state === AppLifecycleState.SUSPENDED
  }

  /**
   * 获取应用统计信息
   */
  getAppStats(appId: string) {
    const app = this.installedApps.get(appId)
    if (!app) return null

    return {
      state: app.state,
      errorCount: app.errorCount,
      crashCount: app.crashCount,
      memoryUsage: app.memoryUsage,
      cpuUsage: app.cpuUsage,
      startedAt: app.startedAt,
      lastActiveAt: app.lastActiveAt,
      uptime: app.startedAt ? Date.now() - app.startedAt.getTime() : 0,
    }
  }

  // 私有方法

  /**
   * 为内置应用挂载 AppRenderer 组件
   */
  private async mountBuiltInApp(appId: string, windowInstance: any): Promise<void> {
    try {
      // 动态导入 Vue 和 AppRenderer
      const { createApp } = await import('vue')
      const AppRenderer = (await import('../ui/components/AppRenderer.vue')).default

      console.log(`[LifecycleManager] 为内置应用 ${appId} 创建 AppRenderer 组件`)

      const app = createApp({
        components: { AppRenderer },
        template: `<AppRenderer :app-id="'${appId}'" :window-id="'${windowInstance.id}'"/>`,
      })

      // 提供系统服务（使用当前实例所在的系统服务）
      app.provide('systemService', {
        getWindowService: () => this.windowService,
        getResourceService: () => this.resourceService,
        getEventService: () => this.eventService,
        getSandboxEngine: () => this.sandboxEngine,
        getLifecycleManager: () => this,
      })

      // 挂载到窗口内容区域
      const contentArea = windowInstance.element?.querySelector('.window-content')
      if (contentArea) {
        app.mount(contentArea)
        console.log(`[LifecycleManager] AppRenderer 组件已挂载到窗口 ${windowInstance.id}`)
      } else {
        throw new Error('未找到窗口内容区域')
      }
    } catch (error) {
      console.error(`内置应用 ${appId} 挂载失败:`, error)
      throw error
    }
  }

  /**
   * 验证应用清单文件
   */
  private validateManifest(manifest: AppManifest): void {
    const required = ['id', 'name', 'version', 'entryPoint']

    for (const field of required) {
      if (!manifest[field as keyof AppManifest]) {
        throw new Error(`清单文件缺少必需字段: ${field}`)
      }
    }

    // 验证版本格式
    if (!/^\d+\.\d+\.\d+/.test(manifest.version)) {
      throw new Error('版本号格式不正确，应为 x.y.z 格式')
    }

    // 验证应用ID格式
    if (!/^[a-zA-Z0-9._-]+$/.test(manifest.id)) {
      throw new Error('应用ID格式不正确')
    }
  }

  /**
   * 验证校验和
   */
  private verifyChecksum(files: Map<string, Blob | string>, expectedChecksum: string): boolean {
    // 简化实现，实际应用中应使用更强的哈希算法
    let content = ''
    for (const [path, data] of files.entries()) {
      content += path + (typeof data === 'string' ? data : data.size)
    }

    const actualChecksum = this.safeBase64Encode(content).slice(0, 32)
    return actualChecksum === expectedChecksum
  }

  /**
   * 安全的 Base64 编码，支持 Unicode 字符
   */
  private safeBase64Encode(str: string): string {
    try {
      // 使用 encodeURIComponent + atob 来处理 Unicode 字符
      return btoa(
        encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(match, p1) {
          return String.fromCharCode(parseInt(p1, 16))
        }),
      )
    } catch (error) {
      // 如果还是失败，使用简单的哈希算法
      let hash = 0
      for (let i = 0; i < str.length; i++) {
        const char = str.charCodeAt(i)
        hash = (hash << 5) - hash + char
        hash = hash & hash // 转换为32位整数
      }
      return Math.abs(hash).toString(36)
    }
  }

  /**
   * 检查权限
   */
  private async checkPermissions(permissions: string[]): Promise<void> {
    for (const permission of permissions) {
      // 这里可以添加权限检查逻辑
      // 目前简单允许所有权限
      console.log(`检查权限: ${permission}`)
    }
  }

  /**
   * 在沙箱中加载应用
   */
  private async loadAppInSandbox(app: AppInstance, sandboxId: string): Promise<void> {
    const appFiles = this.appFiles.get(app.id)
    if (!appFiles) {
      throw new Error('应用文件不存在')
    }

    const entryFile = appFiles.get(app.manifest.entryPoint)
    if (!entryFile) {
      throw new Error('入口文件不存在')
    }

    // 创建应用URL
    const entryUrl = this.createAppUrl(app.id, app.manifest.entryPoint, entryFile)

    // 在沙箱中加载应用
    await this.sandboxEngine.loadApplication(sandboxId, entryUrl)
  }

  /**
   * 创建应用文件URL
   */
  private createAppUrl(appId: string, filePath: string, content: Blob | string): string {
    let blob: Blob

    if (typeof content === 'string') {
      // 确保使用UTF-8编码创建Blob
      const contentType = this.getContentType(filePath)
      const utf8ContentType = contentType.includes('charset')
        ? contentType
        : `${contentType}; charset=utf-8`
      blob = new Blob([content], { type: utf8ContentType })
    } else {
      blob = content
    }

    return URL.createObjectURL(blob)
  }

  /**
   * 获取文件内容类型
   */
  private getContentType(filePath: string): string {
    const ext = filePath.split('.').pop()?.toLowerCase()

    switch (ext) {
      case 'html':
        return 'text/html; charset=utf-8'
      case 'js':
        return 'application/javascript; charset=utf-8'
      case 'css':
        return 'text/css; charset=utf-8'
      case 'json':
        return 'application/json; charset=utf-8'
      case 'png':
        return 'image/png'
      case 'jpg':
      case 'jpeg':
        return 'image/jpeg'
      case 'svg':
        return 'image/svg+xml; charset=utf-8'
      default:
        return 'text/plain; charset=utf-8'
    }
  }

  /**
   * 保存应用到存储
   */
  private async saveAppToStorage(app: AppInstance): Promise<void> {
    const appData = {
      id: app.id,
      manifest: app.manifest,
      installedAt: app.installedAt.toISOString(),
      version: app.version,
      autoStart: app.autoStart,
      persistent: app.persistent,
    }

    await this.resourceService.setStorage('system', `apps.${app.id}`, appData)
  }

  /**
   * 从存储中删除应用
   */
  private async removeAppFromStorage(appId: string): Promise<void> {
    await this.resourceService.removeStorage('system', `apps.${appId}`)
  }

  /**
   * 初始化外置应用发现（已由 SystemServiceIntegration 统一管理）
   * 这个方法保留用于未来可能的扩展，但不再重复启动发现服务
   */
  private async initializeExternalAppDiscovery(): Promise<void> {
    try {
      console.log('[LifecycleManager] 外置应用发现服务已由系统服务集成统一管理')

      // 可以在这里添加应用生命周期管理器特有的外置应用监听逻辑
      // 例如监听外置应用的注册/卸载事件
    } catch (error) {
      console.error('[LifecycleManager] 初始化外置应用监听失败:', error)
    }
  }

  // 已移除：外部应用不再需要注册到 installedApps 中
  // 外部应用在启动时会创建临时实例

  /**
   * 为外置应用加载代码到沙箱
   */
  private async loadExternalAppInSandbox(app: AppInstance, sandboxId: string): Promise<void> {
    try {
      const externalApp = externalAppDiscovery.getApp(app.id)
      if (!externalApp) {
        throw new Error('外置应用信息未找到')
      }

      // 直接使用外置应用的入口URL
      const entryUrl = externalApp.entryPath

      console.log(`[LifecycleManager] 加载外置应用: ${app.id} from ${entryUrl}`)

      // 在沙箱中加载应用
      await this.sandboxEngine.loadApplication(sandboxId, entryUrl)
    } catch (error) {
      console.error(`[LifecycleManager] 加载外置应用到沙箱失败:`, error)
      throw error
    }
  }

  /**
   * 获取所有可用应用（包括内置和外置）
   */
  getAllAvailableApps(): (AppInstance & { isExternal?: boolean })[] {
    const apps: (AppInstance & { isExternal?: boolean })[] = []

    // 添加已安装的应用
    for (const app of this.installedApps.values()) {
      apps.push(app)
    }

    // 添加未注册的外置应用
    for (const externalApp of externalAppDiscovery.getDiscoveredApps()) {
      if (!this.installedApps.has(externalApp.id)) {
        const appInstance: AppInstance & { isExternal: boolean } = {
          id: externalApp.manifest.id,
          manifest: externalApp.manifest,
          state: AppLifecycleState.AVAILABLE,
          processId: '',
          installedAt: externalApp.lastScanned,
          errorCount: 0,
          crashCount: 0,
          memoryUsage: 0,
          cpuUsage: 0,
          version: externalApp.manifest.version,
          autoStart: false,
          persistent: false,
          isExternal: true,
        }
        apps.push(appInstance)
      }
    }

    return apps
  }

  /**
   * 刷新外置应用列表
   */
  async refreshExternalApps(): Promise<void> {
    try {
      await externalAppDiscovery.refresh()
      console.log('[LifecycleManager] 外置应用列表已刷新')
    } catch (error) {
      console.error('[LifecycleManager] 刷新外置应用列表失败:', error)
    }
  }

  /**
   * 加载已安装的应用
   */
  private async loadInstalledApps(): Promise<void> {
    try {
      // 从存储中加载应用列表
      const appsData = (await this.resourceService.getStorage('system', 'apps')) || {}

      for (const [appId, appData] of Object.entries(appsData as Record<string, any>)) {
        if (appData && typeof appData === 'object') {
          const app: AppInstance = {
            id: appId,
            manifest: appData.manifest,
            state: AppLifecycleState.STOPPED,
            processId: '',
            installedAt: new Date(appData.installedAt),
            errorCount: 0,
            crashCount: 0,
            memoryUsage: 0,
            cpuUsage: 0,
            version: appData.version,
            autoStart: appData.autoStart || false,
            persistent: appData.persistent || false,
          }

          this.updateAppState(app, AppLifecycleState.INSTALLED)
          this.installedApps.set(appId, app)
        }
      }

      console.log(`已加载 ${this.installedApps.size} 个已安装应用`)
    } catch (error) {
      console.error('加载已安装应用失败:', error)
    }
  }

  /**
   * 设置事件监听器
   */
  private setupEventListeners(): void {
    // 监听沙箱状态变化
    this.eventService.subscribe('system', 'sandbox-state-change', (message) => {
      const { sandboxId, newState } = message.payload

      // 查找对应的应用
      for (const app of this.installedApps.values()) {
        if (app.sandboxId === sandboxId) {
          if (newState === 'error') {
            this.handleAppError(app.id, new Error('沙箱错误'))
          } else if (newState === 'destroyed') {
            this.handleAppCrash(app.id, '沙箱被销毁')
          }
          break
        }
      }
    })

    // 监听性能告警
    this.eventService.subscribe('system', 'performance-alert', (message) => {
      const { sandboxId, type, usage, limit } = message.payload

      for (const app of this.installedApps.values()) {
        if (app.sandboxId === sandboxId) {
          if (type === 'memory') {
            app.memoryUsage = usage
          } else if (type === 'cpu') {
            app.cpuUsage = usage
          }

          console.warn(`应用 ${app.id} ${type} 使用量 ${usage} 超过限制 ${limit}`)
          break
        }
      }
    })
  }

  /**
   * 处理应用错误
   */
  private handleAppError(appId: string, error: Error): void {
    const app = this.installedApps.get(appId)
    if (!app) return

    app.errorCount++

    this.eventService.sendMessage('system', 'app-lifecycle', {
      type: 'error',
      appId,
      error: error.message,
    })

    console.error(`应用 ${appId} 发生错误:`, error)
  }

  /**
   * 处理应用崩溃
   */
  private handleAppCrash(appId: string, reason: string): void {
    const app = this.installedApps.get(appId)
    if (!app) return

    app.crashCount++
    this.updateAppState(app, AppLifecycleState.CRASHED)

    // 清理资源
    if (app.processId) {
      this.runningProcesses.delete(app.processId)
    }

    // 注意：状态变更消息由updateAppState方法自动发送，不需要手动发送

    console.error(`应用 ${appId} 崩溃: ${reason}`)
  }

  /**
   * 更新应用状态
   */
  private updateAppState(app: AppInstance, newState: AppLifecycleState): void {
    const oldState = app.state
    app.state = newState

    this.eventService.sendMessage('system', 'app-lifecycle', {
      type: 'stateChanged',
      appId: app.id,
      newState,
      oldState,
    })
  }
}