/**
 * 数据库适配器桥接器
 * 将旧的DatabaseAdapter接口适配到新的StorageAdapter接口，确保向后兼容性
 */

import { DatabaseAdapter as LegacyDatabaseAdapter } from '../interfaces/DatabaseAdapter';
import { StorageAdapter, StorageConfig, QueryCondition, SortOption } from '../interfaces/StorageAdapter';

/**
 * 数据库适配器桥接器类
 * 用于将旧的数据库适配器转换为新的存储适配器接口
 */
export class DatabaseAdapterBridge implements StorageAdapter {
  /**
   * 构造函数
   * @param legacyAdapter 旧的数据库适配器实例
   */
  constructor(private legacyAdapter: LegacyDatabaseAdapter) {}
  
  /**
   * 初始化存储连接
   * 适配旧适配器的initialize方法
   */
  public async initialize(config: StorageConfig): Promise<void> {
    // 将新配置转换为旧配置格式
    const legacyConfig = {
      url: config.connection?.url,
      host: config.connection?.host,
      port: config.connection?.port,
      database: config.connection?.database,
      username: config.connection?.username,
      password: config.connection?.password,
      ...config.connection
    };
    
    // 调用旧适配器的initialize方法
    await this.legacyAdapter.initialize(legacyConfig);
  }
  
  /**
   * 关闭存储连接
   * 直接调用旧适配器的close方法
   */
  public async close(): Promise<void> {
    await this.legacyAdapter.close();
  }
  
  /**
   * 创建记录
   * 适配旧适配器的create方法
   */
  public async create<T>(namespace: string, data: Partial<T>): Promise<T> {
    return this.legacyAdapter.create<T>(namespace, data);
  }
  
  /**
   * 根据ID获取记录
   * 适配旧适配器的getById方法
   */
  public async getById<T>(namespace: string, id: string): Promise<T | null> {
    return this.legacyAdapter.getById<T>(namespace, id);
  }
  
  /**
   * 根据条件查询记录
   * 适配旧适配器的find方法
   */
  public async find<T>(
    namespace: string, 
    query?: QueryCondition, 
    skip: number = 0, 
    limit: number = 100,
    sort?: SortOption
  ): Promise<{data: T[], total: number}> {
    // 将新查询条件转换为旧格式（简化版）
    const legacyQuery = this.convertToLegacyQuery(query || {});
    
    // 调用旧适配器的find方法
    return this.legacyAdapter.find<T>(namespace, legacyQuery, skip, limit, sort);
  }
  
  /**
   * 更新记录
   * 适配旧适配器的update方法
   */
  public async update<T>(namespace: string, id: string, data: Partial<T>): Promise<T | null> {
    return this.legacyAdapter.update<T>(namespace, id, data);
  }
  
  /**
   * 删除记录
   * 适配旧适配器的delete方法
   */
  public async delete(namespace: string, id: string): Promise<boolean> {
    return this.legacyAdapter.delete(namespace, id);
  }
  
  /**
   * 批量创建记录
   * 适配旧适配器的bulkCreate方法
   */
  public async bulkCreate<T>(namespace: string, dataList: Partial<T>[]): Promise<T[]> {
    return this.legacyAdapter.bulkCreate<T>(namespace, dataList);
  }
  
  /**
   * 检查存储是否可用
   * 简化实现，假设适配器初始化后即为可用
   */
  public async isAvailable(): Promise<boolean> {
    // 简化实现，在实际项目中可能需要更复杂的健康检查逻辑
    return true;
  }
  
  /**
   * 将新查询条件格式转换为旧格式
   * @param query 新格式的查询条件
   * @returns 转换后的旧格式查询条件
   */
  private convertToLegacyQuery(query: QueryCondition): Record<string, any> {
    const legacyQuery: Record<string, any> = {};
    
    // 转换基本字段条件
    for (const [key, value] of Object.entries(query)) {
      // 跳过特殊查询操作符
      if (key.startsWith('$')) continue;
      
      legacyQuery[key] = value;
    }
    
    // 转换特殊查询操作符（简化版）
    // 在实际项目中可能需要更复杂的转换逻辑
    if (query.$like) {
      for (const [field, pattern] of Object.entries(query.$like)) {
        legacyQuery[field] = { $like: pattern };
      }
    }
    
    if (query.$in) {
      for (const [field, values] of Object.entries(query.$in)) {
        legacyQuery[field] = { $in: values };
      }
    }
    
    // 处理逻辑操作符
    if (query.$and) {
      legacyQuery.$and = query.$and.map((q: QueryCondition) => this.convertToLegacyQuery(q));
    }
    
    if (query.$or) {
      legacyQuery.$or = query.$or.map((q: QueryCondition) => this.convertToLegacyQuery(q));
    }
    
    return legacyQuery;
  }
}

/**
 * 创建数据库适配器桥接器
 * @param legacyAdapter 旧的数据库适配器实例
 * @returns 桥接后的存储适配器实例
 */
export function createAdapterBridge(legacyAdapter: LegacyDatabaseAdapter): StorageAdapter {
  return new DatabaseAdapterBridge(legacyAdapter);
}