/**
 * 存储适配器基类
 * 提供通用功能实现，简化存储适配器的开发
 */

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

/**
 * 存储适配器基类
 * 实现了StorageAdapter接口的通用方法，并提供辅助功能
 */
export abstract class BaseStorageAdapter implements StorageAdapter {
  // 存储配置
  protected config: StorageConfig;
  
  // 是否已初始化标志
  protected initialized = false;
  
  /**
   * 构造函数
   */
  constructor() {
    this.config = { type: 'base' }; // 默认配置
  }
  
  /**
   * 初始化存储连接
   * @param config 存储配置
   */
  public async initialize(config: StorageConfig): Promise<void> {
    if (!config) {
      throw new Error('Storage configuration is required');
    }
    
    this.config = config;
    this.initialized = true;
  }
  
  /**
   * 关闭存储连接
   */
  public async close(): Promise<void> {
    this.initialized = false;
  }
  
  /**
   * 检查是否已初始化
   * @throws DatabaseError 当未初始化时抛出错误
   */
  protected ensureInitialized(): void {
    if (!this.initialized) {
      throw new DatabaseError('Storage adapter not initialized');
    }
  }
  
  /**
   * 生成唯一ID
   * @returns 唯一ID字符串
   */
  protected generateId(): string {
    return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
  }
  
  /**
   * 标准化查询条件
   * @param query 查询条件
   * @returns 标准化后的查询条件
   */
  protected normalizeQuery(query?: QueryCondition): Record<string, any> {
    if (!query) return {};
    return { ...query };
  }
  
  /**
   * 标准化排序条件
   * @param sort 排序条件
   * @returns 标准化后的排序条件
   */
  protected normalizeSort(sort?: SortOption): Record<string, 'asc' | 'desc'> {
    if (!sort) return {};
    return { ...sort };
  }
  
  /**
   * 检查参数有效性
   * @param namespace 命名空间
   * @param data 数据对象
   * @throws Error 参数无效时抛出错误
   */
  protected validateParams(namespace: string, data?: any): void {
    if (!namespace || typeof namespace !== 'string') {
      throw new Error('Invalid namespace');
    }
    
    if (data !== undefined && typeof data !== 'object') {
      throw new Error('Data must be an object');
    }
  }
  
  /**
   * 创建记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract create<T>(namespace: string, data: Partial<T>): Promise<T>;
  
  /**
   * 根据ID获取记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract getById<T>(namespace: string, id: string): Promise<T | null>;
  
  /**
   * 根据条件查询记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract find<T>(
    namespace: string, 
    query?: QueryCondition, 
    skip?: number, 
    limit?: number,
    sort?: SortOption
  ): Promise<{data: T[], total: number}>;
  
  /**
   * 更新记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract update<T>(namespace: string, id: string, data: Partial<T>): Promise<T | null>;
  
  /**
   * 删除记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract delete(namespace: string, id: string): Promise<boolean>;
  
  /**
   * 批量创建记录（抽象方法）
   * 由具体实现类提供实现
   */
  public abstract bulkCreate<T>(namespace: string, dataList: Partial<T>[]): Promise<T[]>;
  
  /**
   * 检查存储是否可用
   * @returns 是否可用
   */
  public async isAvailable(): Promise<boolean> {
    return this.initialized;
  }
}