/**
 * DomainDAO实现类
 */

import { Domain } from '../models/Domain';
import { StorageAdapter } from '../interfaces/StorageAdapter';
import { DomainDAO } from '../interfaces/DomainDAO';
import { DatabaseError } from '../exceptions/DatabaseError';

/**
 * DomainDAO的具体实现，通过数据库适配器与不同数据库交互
 */
export class DomainDAOImpl implements DomainDAO {
  private static readonly COLLECTION_NAME = 'domains';

  /**
   * 构造函数
   * @param adapter 存储适配器
   */
  constructor(private adapter: StorageAdapter) {}

  /**
   * 初始化DAO
   */
  public async initialize(): Promise<void> {
    // DAO初始化依赖于adapter的初始化
    // 这里可以进行一些额外的初始化工作，如创建索引等
  }

  /**
   * 关闭DAO
   */
  public async close(): Promise<void> {
    // DAO关闭依赖于adapter的关闭
  }

  /**
   * 创建域名记录
   */
  public async create(domain: Domain): Promise<Domain> {
    try {
      // 添加时间戳
      const now = new Date();
      const domainToCreate = {
        ...domain,
        createdAt: now,
        updatedAt: now
      };
      
      return await this.adapter.create<Domain>(
        DomainDAOImpl.COLLECTION_NAME,
        domainToCreate
      );
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to create domain: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 根据ID获取域名
   */
  public async findById(id: string): Promise<Domain | null> {
    try {
      return await this.adapter.getById<Domain>(DomainDAOImpl.COLLECTION_NAME, id);
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to find domain by ID: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 根据名称获取域名
   */
  public async findByName(name: string): Promise<Domain | null> {
    try {
      // 在MongoDB中，_id是一个特殊字段，需要特殊处理
      // 这里简单处理，通过find方法查询name字段
      const { data } = await this.adapter.find<Domain>(
        DomainDAOImpl.COLLECTION_NAME,
        { name },
        0, // skip
        1 // limit - 只返回一条
      );
      
      return data.length > 0 ? data[0] : null;
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to find domain by name: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 根据条件查询域名列表
   */
  public async find(query?: any, skip = 0, limit = 0, sort?: any, projection?: Record<string, 1 | 0>): Promise<Domain[]> {
    try {
      const result = await this.adapter.find<Domain>(
        DomainDAOImpl.COLLECTION_NAME,
        query || {},
        skip,
        limit,
        sort
      );
      
      return result.data;
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to find domains: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 更新域名
   */
  public async update(id: string, domain: Partial<Domain>): Promise<Domain | null> {
    try {
      // 更新时间戳
      const domainToUpdate = {
        ...domain,
        updatedAt: new Date()
      };
      
      return await this.adapter.update<Domain>(
        DomainDAOImpl.COLLECTION_NAME,
        id,
        domainToUpdate
      );
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to update domain: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 删除域名
   */
  public async delete(id: string): Promise<boolean> {
    try {
      return await this.adapter.delete(DomainDAOImpl.COLLECTION_NAME, id);
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to delete domain: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * 批量创建域名
   */
  public async bulkCreate(domains: Domain[]): Promise<Domain[]> {
    try {
      // 添加时间戳到所有域名
      const now = new Date();
      const domainsToCreate = domains.map(domain => ({
        ...domain,
        createdAt: now,
        updatedAt: now
      }));
      
      return await this.adapter.bulkCreate<Domain>(
        DomainDAOImpl.COLLECTION_NAME,
        domainsToCreate
      );
    } catch (error) {
      if (error instanceof DatabaseError) {
        throw error;
      }
      throw new DatabaseError(`Failed to bulk create domains: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
}