// DataBaseUtil - 数据库工具类
import { relationalStore } from '@kit.ArkData';
import { common } from '@kit.AbilityKit';
import Logger from './Logger';

const TAG = 'heanup DataBaseUtil';

export class DataBaseUtil {
  private static instance: DataBaseUtil;
  private rdbStore: relationalStore.RdbStore | null = null;
  private context: common.Context | undefined;

  public static getInstance(): DataBaseUtil {
    if (!DataBaseUtil.instance) {
      DataBaseUtil.instance = new DataBaseUtil();
    }
    return DataBaseUtil.instance;
  }

  public setContext(context: common.Context): void {
    this.context = context;
  }

  public async getDB(): Promise<relationalStore.RdbStore> {
    if (this.rdbStore) {
      return this.rdbStore;
    }

    if (!this.context) {
      const err = new Error('Context未设置,请先调用setContext');
      Logger.error(TAG, err.message);
      throw err;
    }

    const config: relationalStore.StoreConfig = {
      name: 'mediaDB.db',
      securityLevel: relationalStore.SecurityLevel.S1
    };

    try {
      this.rdbStore = await relationalStore.getRdbStore(this.context, config);
      Logger.info(TAG, '数据库初始化成功');
      return this.rdbStore;
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `数据库初始化失败: ${error.message}`);
      throw error;
    }
  }

  // 执行SQL语句
  public async executeSql(sql: string): Promise<void> {
    try {
      const db = await this.getDB();
      await db.executeSql(sql);
      Logger.info(TAG, `执行SQL成功: ${sql.substring(0, 50)}...`);
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `执行SQL失败: ${error.message}`);
      throw error;
    }
  }

  // 插入数据
  public async insert(tableName: string, values: relationalStore.ValuesBucket): Promise<number> {
    try {
      const db = await this.getDB();
      const rowId = await db.insert(tableName, values);
      Logger.info(TAG, `插入数据成功,行ID: ${rowId}`);
      return rowId;
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `插入数据失败: ${error.message}`);
      throw error;
    }
  }

  // 更新数据
  public async update(tableName: string, values: relationalStore.ValuesBucket, predicates: relationalStore.RdbPredicates): Promise<number> {
    try {
      const db = await this.getDB();
      const rows = await db.update(values, predicates);
      Logger.info(TAG, `更新数据成功,影响行数: ${rows}`);
      return rows;
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `更新数据失败: ${error.message}`);
      throw error;
    }
  }

  // 删除数据
  public async delete(predicates: relationalStore.RdbPredicates): Promise<number> {
    try {
      const db = await this.getDB();
      const rows = await db.delete(predicates);
      Logger.info(TAG, `删除数据成功,影响行数: ${rows}`);
      return rows;
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `删除数据失败: ${error.message}`);
      throw error;
    }
  }

  // 查询数据
  public async query(predicates: relationalStore.RdbPredicates, columns?: Array<string>): Promise<relationalStore.ResultSet> {
    try {
      const db = await this.getDB();
      const resultSet = await db.query(predicates, columns);
      return resultSet;
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `查询数据失败: ${error.message}`);
      throw error;
    }
  }

  // 查询数据(简化版,用于RemoteDriveManager)
  public async queryData(tableName: string, columns: Array<string>, predicates?: relationalStore.RdbPredicates): Promise<relationalStore.ResultSet> {
    try {
      const db = await this.getDB();
      if (predicates) {
        return await db.query(predicates, columns);
      } else {
        const pred = new relationalStore.RdbPredicates(tableName);
        return await db.query(pred, columns);
      }
    } catch (err) {
      const error = err as Error;
      Logger.error(TAG, `查询数据失败: ${error.message}`);
      throw error;
    }
  }

  // 插入数据(简化版,用于RemoteDriveManager)
  public async insertData(tableName: string, values: relationalStore.ValuesBucket): Promise<number> {
    return await this.insert(tableName, values);
  }

  // 更新数据(简化版,用于RemoteDriveManager)
  public async updateData(tableName: string, values: relationalStore.ValuesBucket, predicates: relationalStore.RdbPredicates): Promise<number> {
    return await this.update(tableName, values, predicates);
  }

  // 删除数据(简化版,用于RemoteDriveManager)
  public async deleteData(predicates: relationalStore.RdbPredicates): Promise<number> {
    return await this.delete(predicates);
  }

  // 查询其他设备的表(简化版占位)
  public async queryTableFromOtherDevice(tableName: string): Promise<relationalStore.ResultSet | null> {
    Logger.info(TAG, `查询其他设备表: ${tableName}`);
    // TODO: 实现跨设备查询逻辑
    return null;
  }

  // 关闭数据库
  public async closeDB(): Promise<void> {
    if (this.rdbStore) {
      try {
        await relationalStore.deleteRdbStore(this.context!, 'mediaDB.db');
        this.rdbStore = null;
        Logger.info(TAG, '数据库关闭成功');
      } catch (error) {
        Logger.error(TAG, `数据库关闭失败: ${error}`);
      }
    }
  }
}