/**
 * 存储服务注册中心
 * 用于全局管理和访问不同的存储适配器实例
 */

import { StorageAdapter, StorageConfig } from '../interfaces/StorageAdapter';
import { StorageFactory } from './StorageFactory';
import { DatabaseError } from '../exceptions/DatabaseError';

/**
 * 存储服务注册中心类
 * 单例模式实现，提供全局存储适配器管理
 */
export class StorageRegistry {
  // 单例实例
  private static instance: StorageRegistry;
  
  // 存储适配器实例缓存
  private adapterInstances: Map<string, StorageAdapter> = new Map();
  
  // 默认存储适配器键
  private defaultAdapterKey = 'default';
  
  /**
   * 私有构造函数
   */
  private constructor() {}
  
  /**
   * 获取存储注册中心单例实例
   * @returns 存储注册中心实例
   */
  public static getInstance(): StorageRegistry {
    if (!StorageRegistry.instance) {
      StorageRegistry.instance = new StorageRegistry();
    }
    return StorageRegistry.instance;
  }
  
  /**
   * 注册存储适配器实例
   * @param key 适配器标识键
   * @param config 存储配置
   * @returns 注册的适配器实例
   */
  public async registerAdapter(key: string, config: StorageConfig): Promise<StorageAdapter> {
    try {
      // 检查是否已存在相同键的适配器
      if (this.adapterInstances.has(key)) {
        // 关闭现有适配器
        await this.unregisterAdapter(key);
      }
      
      // 创建并初始化适配器
      const adapter = await StorageFactory.createAndInitializeAdapter(config);
      
      // 保存适配器实例
      this.adapterInstances.set(key, adapter);
      
      // 如果是第一个注册的适配器，自动设为默认适配器
      if (this.adapterInstances.size === 1 && key !== this.defaultAdapterKey) {
        this.adapterInstances.set(this.defaultAdapterKey, adapter);
      }
      
      return adapter;
    } catch (error) {
      throw new DatabaseError(
        `Failed to register storage adapter '${key}': ${error instanceof Error ? error.message : 'Unknown error'}`
      );
    }
  }
  
  /**
   * 设置默认存储适配器
   * @param key 适配器标识键
   */
  public setDefaultAdapter(key: string): void {
    const adapter = this.adapterInstances.get(key);
    if (!adapter) {
      throw new Error(`Adapter with key '${key}' not found`);
    }
    
    this.adapterInstances.set(this.defaultAdapterKey, adapter);
  }
  
  /**
   * 获取存储适配器实例
   * @param key 适配器标识键，默认为default
   * @returns 存储适配器实例
   */
  public getAdapter(key: string = this.defaultAdapterKey): StorageAdapter {
    const adapter = this.adapterInstances.get(key);
    if (!adapter) {
      throw new DatabaseError(`Storage adapter '${key}' not registered`);
    }
    
    return adapter;
  }
  
  /**
   * 注销存储适配器实例
   * @param key 适配器标识键
   * @returns 是否成功注销
   */
  public async unregisterAdapter(key: string): Promise<boolean> {
    try {
      const adapter = this.adapterInstances.get(key);
      if (!adapter) {
        return false;
      }
      
      // 关闭适配器
      await adapter.close();
      
      // 从实例缓存中移除
      this.adapterInstances.delete(key);
      
      // 如果注销的是默认适配器且还有其他适配器，设置第一个适配器为默认
      if (key === this.defaultAdapterKey && this.adapterInstances.size > 0) {
        const firstKey = this.adapterInstances.keys().next().value;
        if (firstKey) {
          const firstAdapter = this.adapterInstances.get(firstKey);
          if (firstAdapter) {
            this.adapterInstances.set(this.defaultAdapterKey, firstAdapter);
          }
        }
      }
      
      return true;
    } catch (error) {
      console.error(`Error unregistering adapter '${key}':`, error);
      return false;
    }
  }
  
  /**
   * 获取所有已注册的适配器键
   * @returns 适配器键数组
   */
  public getRegisteredAdapterKeys(): string[] {
    return Array.from(this.adapterInstances.keys())
      .filter(key => key !== this.defaultAdapterKey);
  }
  
  /**
   * 检查适配器是否已注册
   * @param key 适配器标识键
   * @returns 是否已注册
   */
  public isAdapterRegistered(key: string): boolean {
    return this.adapterInstances.has(key);
  }
  
  /**
   * 清除所有注册的适配器
   */
  public async clearAllAdapters(): Promise<void> {
    const keys = Array.from(this.adapterInstances.keys());
    
    for (const key of keys) {
      await this.unregisterAdapter(key);
    }
  }
}

/**
 * 存储注册中心单例导出
 */
export const storageRegistry = StorageRegistry.getInstance();