vue-desktop/src/services/di/ServiceRegistry.ts

import type { IServiceContainer, ServiceFactory } from './IServiceContainer'
import { ServiceContainerImpl } from './ServiceContainerImpl'

/**
 * 服务ID常量
 */
export enum ServiceIds {
  RESOURCE_SERVICE = 'resourceService',
  WINDOW_FORM_SERVICE = 'windowFormService',
  SANDBOX_ENGINE = 'sandboxEngine',
  LIFECYCLE_MANAGER = 'lifecycleManager',
  SYSTEM_SERVICE = 'systemService',
  EVENT_BUILDER = 'eventBuilder',
  EXTERNAL_APP_DISCOVERY = 'externalAppDiscovery',
  ERROR_HANDLER = 'errorHandler'
}

/**
 * 服务注册表
 * 负责注册所有系统服务
 */
export class ServiceRegistry {
  private static instance: ServiceRegistry
  private container: IServiceContainer

  private constructor() {
    this.container = new ServiceContainerImpl()
  }

  /**
   * 获取服务注册表单例
   */
  public static getInstance(): ServiceRegistry {
    if (!ServiceRegistry.instance) {
      ServiceRegistry.instance = new ServiceRegistry()
    }
    return ServiceRegistry.instance
  }

  /**
   * 获取服务容器实例
   */
  public getContainer(): IServiceContainer {
    return this.container
  }

  /**
   * 注册所有服务
   * 注意：服务注册顺序应按照依赖关系排列
   */
  public registerAllServices(): void {
    // 注册基本服务 - 这些服务没有其他依赖
    this.registerEventBuilder()
    this.registerExternalAppDiscovery()
    this.registerResourceService()
    this.registerErrorHandler()

    // 注册核心服务 - 按照依赖关系顺序注册
    this.registerWindowFormService()
    this.registerSandboxEngine()
    this.registerLifecycleManager()
    this.registerSystemService()
  }

  /**
   * 注册事件构建器服务
   */
  private registerEventBuilder(): void {
    this.container.register(ServiceIds.EVENT_BUILDER, async () => {
      const { EventBuilderImpl } = await import('@/events/impl/EventBuilderImpl')
      return new EventBuilderImpl()
    })
  }

  /**
   * 注册外部应用发现服务
   */
  private registerExternalAppDiscovery(): void {
    this.container.register(ServiceIds.EXTERNAL_APP_DISCOVERY, async () => {
      // 延迟导入避免循环依赖
      const { externalAppDiscovery } = await import('../ExternalAppDiscovery')
      return externalAppDiscovery
    })
  }

  /**
   * 注册资源服务
   */
  private registerResourceService(): void {
    this.container.register(
      ServiceIds.RESOURCE_SERVICE,
      async (container) => {
        // 延迟导入避免循环依赖
        const { ResourceService } = await import('../ResourceService')
        return new ResourceService(container.getService(ServiceIds.EVENT_BUILDER))
      },
      [ServiceIds.EVENT_BUILDER]
    )
  }

  /**
   * 注册窗口表单服务
   */
  private registerWindowFormService(): void {
    this.container.register(
      ServiceIds.WINDOW_FORM_SERVICE,
      async (container) => {
        // 延迟导入避免循环依赖
        const { WindowFormService } = await import('../WindowFormService')
        return new WindowFormService(container.getService(ServiceIds.EVENT_BUILDER))
      },
      [ServiceIds.EVENT_BUILDER]
    )
  }

  /**
   * 注册沙箱引擎服务
   */
  private registerSandboxEngine(): void {
    this.container.register(
      ServiceIds.SANDBOX_ENGINE,
      async (container) => {
        // 延迟导入避免循环依赖
        const { ApplicationSandboxEngine } = await import('../ApplicationSandboxEngine')
        return new ApplicationSandboxEngine(
          container.getService(ServiceIds.RESOURCE_SERVICE),
          container
        )
      },
      [ServiceIds.RESOURCE_SERVICE]
    )
  }

  /**
   * 注册生命周期管理器服务
   */
  private registerLifecycleManager(): void {
    this.container.register(
      ServiceIds.LIFECYCLE_MANAGER,
      async (container) => {
        // 延迟导入避免循环依赖
        const { ApplicationLifecycleManager } = await import('../ApplicationLifecycleManager')
        return new ApplicationLifecycleManager(
          container.getService(ServiceIds.RESOURCE_SERVICE),
          container.getService(ServiceIds.SANDBOX_ENGINE),
          container.getService(ServiceIds.WINDOW_FORM_SERVICE)
        )
      },
      [
        ServiceIds.RESOURCE_SERVICE,
        ServiceIds.SANDBOX_ENGINE,
        ServiceIds.WINDOW_FORM_SERVICE,
        ServiceIds.EXTERNAL_APP_DISCOVERY
      ]
    )
  }

  /**
   * 注册系统服务集成服务
   */
  private registerSystemService(): void {
    this.container.register(
      ServiceIds.SYSTEM_SERVICE,
      async (container) => {
        // 延迟导入避免循环依赖
        const { SystemServiceIntegration } = await import('../SystemServiceIntegration')
        return new SystemServiceIntegration(container)
      },
      [
        ServiceIds.RESOURCE_SERVICE,
        ServiceIds.WINDOW_FORM_SERVICE,
        ServiceIds.SANDBOX_ENGINE,
        ServiceIds.LIFECYCLE_MANAGER,
        ServiceIds.EVENT_BUILDER,
        ServiceIds.ERROR_HANDLER
      ]
    )
  }
  
  /**
   * 注册错误处理服务
   */
  private registerErrorHandler(): void {
    this.container.register(
      ServiceIds.ERROR_HANDLER,
      async () => {
        // 延迟导入避免循环依赖
        const { ErrorHandlerImpl } = await import('../impl/ErrorHandlerImpl')
        return new ErrorHandlerImpl()
      },
      [] // 错误处理服务应尽量减少依赖，避免在错误处理过程中出现循环依赖
    )
  }
}