vue-desktop/src/services/SystemServiceIntegration.ts

import { reactive, ref } from 'vue'
import { EventBuilderImpl } from '@/events/impl/EventBuilderImpl'
import type {
  IEventBuilder,
  ISystemBuiltInEventMap,
  IWindowFormDataUpdateParams
} from '@/events/IEventBuilder'
import type { ResourceType } from './ResourceService'

// 导入所有服务
import { WindowFormService } from './windowForm/WindowFormService.ts'
import { ResourceService } from './ResourceService'
import { ApplicationSandboxEngine } from './ApplicationSandboxEngine'
import { ApplicationLifecycleManager } from './ApplicationLifecycleManager'
import { externalAppDiscovery } from './ExternalAppDiscovery'

/**
 * 系统服务配置接口
 */
export interface SystemServiceConfig {
  debug?: boolean // 是否开启调试模式
  autoCleanup?: boolean // 是否自动清理
  cleanupInterval?: number // 自动清理间隔
}

/**
 * 系统状态接口
 */
export interface SystemStatus {
  initialized: boolean // 系统是否初始化完成
  running: boolean // 系统是否运行中
  servicesStatus: {
    windowFormService: boolean // 窗体服务是否启动
    resourceService: boolean // 资源服务是否启动
    sandboxEngine: boolean // 沙箱引擎是否启动
    lifecycleManager: boolean // 生命周期管理器是否启动
  }
  uptime: number // 系统运行时间
  lastError?: string // 最后一次错误
}

/**
 * SDK调用接口
 */
export interface SDKCall {
  requestId: string
  method: string
  data?: any
  appId: string
}

/**
 * 系统服务集成层
 * 统一管理所有核心服务，提供统一的对外接口
 */
export class SystemServiceIntegration {
  private initialized = ref(false)
  private running = ref(false)
  private config: SystemServiceConfig
  private startTime: Date

  // 核心服务实例
  private eventBus: IEventBuilder<ISystemBuiltInEventMap>
  private windowFormService!: WindowFormService
  private resourceService!: ResourceService
  private sandboxEngine!: ApplicationSandboxEngine
  private lifecycleManager!: ApplicationLifecycleManager

  // 系统状态
  private systemStatus = reactive<SystemStatus>({
    initialized: false,
    running: false,
    servicesStatus: {
      windowFormService: false,
      resourceService: false,
      sandboxEngine: false,
      lifecycleManager: false
    },
    uptime: 0
  })

  // 性能监控
  private cleanupInterval: number | null = null
  private performanceInterval: number | null = null

  constructor(config: SystemServiceConfig = {}) {
    this.config = {
      debug: false,
      autoCleanup: true,
      cleanupInterval: 5 * 60 * 1000, // 5分钟
      ...config
    }

    this.startTime = new Date()
    this.eventBus = new EventBuilderImpl<ISystemBuiltInEventMap>()

    this.setupGlobalErrorHandling()
  }

  /**
   * 初始化系统服务
   */
  public async initialize(): Promise<void> {
    if (this.initialized.value) {
      throw new Error('系统服务已初始化')
    }

    try {
      console.log('开始初始化系统服务...')

      // 按依赖顺序初始化服务
      await this.initializeServices()

      // 设置服务间通信
      this.setupServiceCommunication()

      // 设置SDK消息处理
      this.setupSDKMessageHandling()

      // 启动自动清理
      if (this.config.autoCleanup) {
        this.startAutoCleanup()
      }

      // 启动外置应用发现服务
      // 注意：外置应用发现服务统一由 SystemServiceIntegration 管理，
      // ApplicationLifecycleManager 只负责使用已发现的应用，避免重复启动
      console.log('启动外置应用发现服务...')
      await externalAppDiscovery.startDiscovery()

      this.initialized.value = true
      this.running.value = true
      this.systemStatus.initialized = true
      this.systemStatus.running = true

      console.log('系统服务初始化完成')
    } catch (error) {
      console.error('系统服务初始化失败:', error)
      this.systemStatus.lastError = error instanceof Error ? error.message : String(error)
      throw error
    }
  }

  /**
   * 获取系统状态
   */
  getSystemStatus(): SystemStatus {
    return { ...this.systemStatus }
  }

  /**
   * 获取窗体服务
   */
  getWindowFormService(): WindowFormService {
    this.checkInitialized()
    return this.windowFormService
  }

  /**
   * 获取资源服务
   */
  getResourceService(): ResourceService {
    this.checkInitialized()
    return this.resourceService
  }

  /**
   * 获取沙箱引擎
   */
  getSandboxEngine(): ApplicationSandboxEngine {
    this.checkInitialized()
    return this.sandboxEngine
  }

  /**
   * 获取生命周期管理器
   */
  getLifecycleManager(): ApplicationLifecycleManager {
    this.checkInitialized()
    return this.lifecycleManager
  }

  /**
   * 处理SDK调用
   */
  async handleSDKCall(call: SDKCall): Promise<any> {
    this.checkInitialized()

    const { requestId, method, data, appId } = call

    try {
      this.debugLog(`处理SDK调用: ${method}`, { appId, data })

      const result = await this.executeSDKMethod(method, data, appId)

      return {
        success: true,
        data: result,
        requestId
      }
    } catch (error) {
      console.error('SDK调用失败:', error)

      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
        requestId
      }
    }
  }

  /**
   * 重启系统服务
   */
  async restart(): Promise<void> {
    console.log('重启系统服务...')

    await this.shutdown()
    await new Promise((resolve) => setTimeout(resolve, 1000))
    await this.initialize()

    console.log('系统服务重启完成')
  }

  /**
   * 关闭系统服务
   */
  public async shutdown(): Promise<void> {
    console.log('关闭系统服务...')

    this.running.value = false
    this.systemStatus.running = false

    // 停止定时器
    if (this.cleanupInterval) {
      clearInterval(this.cleanupInterval)
      this.cleanupInterval = null
    }

    if (this.performanceInterval) {
      clearInterval(this.performanceInterval)
      this.performanceInterval = null
    }

    // 停止外置应用发现服务（由 SystemServiceIntegration 统一管理）
    externalAppDiscovery.stopDiscovery()

    // 按相反顺序关闭服务
    try {
      if (this.lifecycleManager) {
        // 停止所有运行中的应用
        const runningApps = this.lifecycleManager.getRunningApps()
        for (const app of runningApps) {
          await this.lifecycleManager.stopApp(app.id)
        }
      }

      if (this.sandboxEngine) {
        this.sandboxEngine.destroy()
      }

      if (this.windowFormService) {
        // 关闭所有窗体
        const windows = this.windowFormService.getAllWindows()
        for (const window of windows) {
          await this.windowFormService.destroyWindow(window.id)
        }
      }
    } catch (error) {
      console.error('关闭服务时发生错误:', error)
    }

    this.initialized.value = false
    this.systemStatus.initialized = false

    console.log('系统服务已关闭')
  }

  /**
   * 初始化所有服务
   */
  private async initializeServices(): Promise<void> {
    // 1. 初始化资源服务
    console.log('初始化资源服务...')
    this.resourceService = new ResourceService(this.eventBus)
    this.systemStatus.servicesStatus.resourceService = true

    // 3. 初始化窗体服务
    console.log('初始化窗体服务...')
    this.windowFormService = new WindowFormService(this.eventBus)
    this.systemStatus.servicesStatus.windowFormService = true

    // 4. 初始化沙箱引擎
    console.log('初始化沙箱引擎...')
    this.sandboxEngine = new ApplicationSandboxEngine(this.resourceService)
    this.systemStatus.servicesStatus.sandboxEngine = true

    // 5. 初始化生命周期管理器
    console.log('初始化生命周期管理器...')
    this.lifecycleManager = new ApplicationLifecycleManager(
      this.windowFormService,
      this.resourceService,
      this.sandboxEngine
    )
    this.systemStatus.servicesStatus.lifecycleManager = true
  }

  /**
   * 设置服务间通信
   */
  private setupServiceCommunication(): void {
    // 监听窗体状态变化（来自 windowFormService 的 onStateChange 事件）
    this.eventBus.subscribe(
      'onWindowStateChanged',
      (windowId: string, newState: string, oldState: string) => {
        console.log(
          `[SystemIntegration] 接收到窗体状态变化事件: ${windowId} ${oldState} -> ${newState}`
        )
      }
    )

    // 监听窗体关闭事件，自动停止对应的应用
    this.eventBus.subscribe('onWindowClose', async (windowId: string) => {
      console.log(`[SystemIntegration] 接收到窗体关闭事件: ${windowId}`)
      // 查找对应的应用
      const runningApps = this.lifecycleManager.getRunningApps()
      for (const app of runningApps) {
        if (app.windowId === windowId) {
          try {
            console.log(`窗口关闭，自动停止应用: ${app.id}`)
            await this.lifecycleManager.stopApp(app.id)
          } catch (error) {
            console.error(`停止应用 ${app.id} 失败:`, error)
          }
          break
        }
      }
    })

    // 监听窗体数据更新事件
    this.eventBus.subscribe('onWindowFormDataUpdate', (data: IWindowFormDataUpdateParams) => {
      console.log(`[SystemIntegration] 接收到窗体数据更新事件:`, data)
    })

    // 监听窗体调整尺寸开始事件
    this.eventBus.subscribe('onWindowFormResizeStart', (windowId: string) => {
      console.log(`[SystemIntegration] 接收到窗体调整尺寸开始事件: ${windowId}`)
    })

    // 监听窗体调整尺寸过程中事件
    this.eventBus.subscribe(
      'onWindowFormResizing',
      (windowId: string, width: number, height: number) => {
        console.log(`[SystemIntegration] 接收到窗体调整尺寸过程中事件: ${windowId}`, {
          width,
          height
        })
      }
    )

    // 监听窗体调整尺寸结束事件
    this.eventBus.subscribe('onWindowFormResizeEnd', (windowId: string) => {
      console.log(`[SystemIntegration] 接收到窗体调整尺寸结束事件: ${windowId}`)
    })
  }

  /**
   * 设置SDK消息处理
   */
  private setupSDKMessageHandling(): void {
    // 监听来自iframe的SDK调用
    window.addEventListener('message', async (event) => {
      const data = event.data
      if (!data) return

      // 处理安全存储消息
      if (data.type?.startsWith('sdk:storage:')) {
        await this.handleStorageMessage(event)
        return
      }

      // 处理其他SDK调用
      if (data.type === 'sdk:call') {
        const call: SDKCall = data
        const result = await this.handleSDKCall(call)

        // 发送响应回iframe
        const iframe = this.findIframeBySource(event.source as Window)
        if (iframe) {
          iframe.contentWindow?.postMessage(
            {
              type: 'system:response',
              ...result
            },
            '*'
          )
        }
      }
    })
  }

  /**
   * 处理安全存储消息
   */
  private async handleStorageMessage(event: MessageEvent): Promise<void> {
    const { type, requestId, appId, key, value } = event.data

    if (!requestId || !appId) {
      console.warn('存储消息缺少必需参数')
      return
    }

    // 验证应用权限
    const app = this.lifecycleManager.getApp(appId)
    if (!app) {
      console.warn(`未找到应用: ${appId}`)
      return
    }

    let result: any = null
    let success = false

    try {
      switch (type) {
        case 'sdk:storage:getWindowForm':
          result = await this.resourceService.getStorage(appId, key)
          success = true
          break

        case 'sdk:storage:set':
          result = await this.resourceService.setStorage(appId, key, value)
          success = result === true
          break

        case 'sdk:storage:removeWindowForm':
          result = await this.resourceService.removeStorage(appId, key)
          success = result === true
          break

        default:
          console.warn(`未知的存储操作: ${type}`)
          return
      }
    } catch (error) {
      console.error('存储操作失败:', error)
      success = false
    }

    // 发送响应回iframe
    const iframe = this.findIframeBySource(event.source as Window)
    if (iframe?.contentWindow) {
      iframe.contentWindow.postMessage(
        {
          type: 'system:storage-response',
          requestId,
          result,
          success
        },
        '*'
      )
    }
  }

  /**
   * 执行SDK方法
   */
  private async executeSDKMethod(method: string, data: any, appId: string): Promise<any> {
    const [service, action] = method.split('.')

    switch (service) {
      case 'window':
        return this.executeWindowMethod(action, data, appId)

      case 'storage':
        return this.executeStorageMethod(action, data, appId)

      case 'network':
        return this.executeNetworkMethod(action, data, appId)

      case 'events':
        return this.executeEventMethod(action, data, appId)

      case 'ui':
        return this.executeUIMethod(action, data, appId)

      case 'system':
        return this.executeSystemMethod(action, data, appId)

      case 'sdk':
        return this.executeSDKMethod(action, data, appId)

      default:
        throw new Error(`未知的服务: ${service}`)
    }
  }

  /**
   * 执行窗体相关方法
   */
  private async executeWindowMethod(action: string, data: any, appId: string): Promise<any> {
    // 查找应用的窗体
    const app = this.lifecycleManager.getApp(appId)
    if (!app?.windowId) {
      throw new Error('应用窗体不存在')
    }

    const windowId = app.windowId

    switch (action) {
      case 'setTitle':
        return this.windowFormService.setWindowTitle(windowId, data.title)

      case 'resize':
        return this.windowFormService.setWindowSize(windowId, data.width, data.height)

      case 'move':
        // 实现窗体移动功能
        const window = this.windowFormService.getWindow(windowId)
        if (window && window.element) {
          // 更新窗体位置
          window.config.x = data.x
          window.config.y = data.y
          window.element.style.left = `${data.x}px`
          window.element.style.top = `${data.y}px`
          window.element.style.transform = 'none' // 确保移除transform
          return true
        }
        return false

      case 'minimize':
        return this.windowFormService.minimizeWindow(windowId)

      case 'maximize':
        return this.windowFormService.maximizeWindow(windowId)

      case 'restore':
        return this.windowFormService.restoreWindow(windowId)

      case 'close':
        return this.lifecycleManager.stopApp(appId)

      case 'getState':
        const windowInfo = this.windowFormService.getWindow(windowId)
        return windowInfo?.state

      case 'getSize':
        const windowData = this.windowFormService.getWindow(windowId)
        return {
          width: windowData?.config.width,
          height: windowData?.config.height
        }

      default:
        throw new Error(`未知的窗体操作: ${action}`)
    }
  }

  /**
   * 执行存储相关方法
   */
  private async executeStorageMethod(action: string, data: any, appId: string): Promise<any> {
    switch (action) {
      case 'set':
        return this.resourceService.setStorage(appId, data.key, data.value)

      case 'get':
        return this.resourceService.getStorage(appId, data.key)

      case 'removeWindowForm':
        return this.resourceService.removeStorage(appId, data.key)

      case 'clear':
        return this.resourceService.clearStorage(appId)

      case 'keys':
        // 需要实现获取所有键的功能
        return []

      case 'has':
        const value = await this.resourceService.getStorage(appId, data.key)
        return value !== null

      case 'getStats':
        return this.resourceService.getStorageUsage(appId)

      default:
        throw new Error(`未知的存储操作: ${action}`)
    }
  }

  /**
   * 执行网络相关方法
   */
  private async executeNetworkMethod(action: string, data: any, appId: string): Promise<any> {
    switch (action) {
      case 'request':
        const response = await this.resourceService.makeNetworkRequest(appId, data.url, data.config)
        return response
          ? {
              data: await response.text(),
              status: response.status,
              statusText: response.statusText,
              headers: {} as Record<string, string>, // 简化headers处理
              url: response.url
            }
          : null

      case 'isOnline':
        return navigator.onLine

      case 'getStats':
        const requests = this.resourceService.getNetworkRequests(appId)
        return {
          requestCount: requests.length,
          failureCount: requests.filter((r) => r.status && r.status >= 400).length,
          averageTime: 0 // 需要实现时间统计
        }

      default:
        throw new Error(`未知的网络操作: ${action}`)
    }
  }

  /**
   * 执行事件相关方法
   */
  private async executeEventMethod(action: string, data: any, appId: string): Promise<any> {
    throw new Error('事件服务已被移除')
  }

  /**
   * 执行UI相关方法
   */
  private async executeUIMethod(action: string, data: any, appId: string): Promise<any> {
    switch (action) {
      case 'showNotification':
        return this.resourceService.showNotification(appId, data.title, data)

      case 'showToast':
        // 需要实现Toast功能
        console.log(`[Toast] ${data.message}`)
        return 'toast-' + Date.now()

      default:
        throw new Error(`未知的UI操作: ${action}`)
    }
  }

  /**
   * 执行系统相关方法
   */
  private async executeSystemMethod(action: string, data: any, appId: string): Promise<any> {
    switch (action) {
      case 'getSystemInfo':
        return {
          platform: navigator.platform,
          userAgent: navigator.userAgent,
          language: navigator.language,
          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
          screenResolution: {
            width: screen.width,
            height: screen.height
          },
          colorDepth: screen.colorDepth,
          pixelRatio: window.devicePixelRatio
        }

      case 'getAppInfo':
        const app = this.lifecycleManager.getApp(appId)
        return app
          ? {
              id: app.id,
              name: app.manifest.name,
              version: app.version,
              permissions: app.manifest.permissions,
              createdAt: app.installedAt,
              lastActiveAt: app.lastActiveAt
            }
          : null

      case 'getClipboard':
        return this.resourceService.getClipboard(appId)

      case 'setClipboard':
        return this.resourceService.setClipboard(appId, data.text)

      case 'getCurrentTime':
        return new Date()

      case 'generateUUID':
        return crypto.randomUUID()

      default:
        throw new Error(`未知的系统操作: ${action}`)
    }
  }

  /**
   * 查找消息来源的iframe
   */
  private findIframeBySource(source: Window): HTMLIFrameElement | null {
    const iframes = Array.from(document.querySelectorAll('iframe'))

    for (const iframe of iframes) {
      if (iframe.contentWindow === source) {
        return iframe
      }
    }

    return null
  }

  /**
   * 开始自动清理
   */
  private startAutoCleanup(): void {
    if (!this.config.cleanupInterval) return

    this.cleanupInterval = setInterval(() => {
      this.debugLog('执行自动清理...')

      // 移除资源服务清理（方法不存在）
      // this.resourceService.cleanup()

      // 移除事件服务清理
      // this.eventService.cleanup()

      // 清理沙箱引擎缓存
      // this.sandboxEngine.cleanup()

      this.debugLog('自动清理完成')
    }, this.config.cleanupInterval!)
  }

  /**
   * 检查是否已初始化
   */
  private checkInitialized(): void {
    if (!this.initialized.value) {
      throw new Error('系统服务未初始化')
    }
  }

  /**
   * 设置全局错误处理
   */
  private setupGlobalErrorHandling(): void {
    window.addEventListener('error', (event) => {
      console.error('全局错误:', event.error)
      this.systemStatus.lastError = event.error?.message || '未知错误'
    })

    window.addEventListener('unhandledrejection', (event) => {
      // console.error('未处理的Promise拒绝:', event.reason)
      this.systemStatus.lastError = event.reason?.message || '未处理的Promise拒绝'
    })
  }

  /**
   * 调试日志
   */
  private debugLog(message: string, data?: any): void {
    if (this.config.debug) {
      console.log(`[SystemService] ${message}`, data)
    }
  }
}