import { distributedKVStore } from '@kit.ArkData';
import { BusinessError } from '@kit.BasicServicesKit';
import { AppUtils } from './AppUtils';
import { Logger } from './Logger';

const TAG = 'KVStoreHelper'

/**
 * 键值型数据库管理类，类似sp，存储变大，单条数据，value<4M
 * TODO 是否需要开线程
 */
export class KVStoreHelper {
  private static _context: Context;
  // TODO 待优化，可以指定数据库名，创建多个数据库。当前没有需求，只创建一个，缓存接口数据用。
  private static _default_store_id: string = 'default_kv_store';
  private kvManager: distributedKVStore.KVManager | undefined = undefined;
  private kvStore: distributedKVStore.SingleKVStore | undefined = undefined;

  private constructor() {
  }

  static init(context: Context) {
    Logger.error(TAG, 'init')
    KVStoreHelper._context = context;
    KVStoreHelper.default.createKVManager()
    KVStoreHelper.default.createKVStore()
  }

  // 静态属性
  static default: KVStoreHelper = new KVStoreHelper();

  private createKVManager() {
    if (this.kvManager) {
      return
    }
    if (!KVStoreHelper._context) {
      Logger.fatal(TAG, 'context is null, must be initialized first')
      return
    }
    let context: Context = KVStoreHelper._context;
    const kvManagerConfig: distributedKVStore.KVManagerConfig = {
      context: context,
      bundleName: AppUtils.getPackageName(context)
    };
    try {
      // 创建KVManager实例
      this.kvManager = distributedKVStore.createKVManager(kvManagerConfig);
      Logger.info(TAG, 'Succeeded in creating KVManager.');
      // 继续创建获取数据库
    } catch (e) {
      let error = e as BusinessError;
      Logger.error(TAG, `Failed to create KVManager. Code:${error.code},message:${error.message}`);
    }
  }

  private createKVStore() {
    if (this.kvStore) {
      return
    }
    if (!this.kvManager) {
      this.createKVManager()
      // 直接拦截，避免陷入循环
      Logger.error(TAG, 'kvManager is null, please re-create it and try again')
      return
    }
    try {
      const options: distributedKVStore.Options = {
        createIfMissing: true,
        encrypt: false,
        backup: false,
        autoSync: false,
        // kvStoreType不填时，默认创建多设备协同数据库
        kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
        securityLevel: distributedKVStore.SecurityLevel.S1
      };
      this.kvManager?.getKVStore<distributedKVStore.SingleKVStore>(KVStoreHelper._default_store_id, options,
        (err, store: distributedKVStore.SingleKVStore) => {
          if (err) {
            Logger.error(TAG, `Failed to get KVStore: Code:${err.code},message:${err.message}`);
            return;
          }
          Logger.info(TAG, 'Succeeded in getting KVStore.');
          this.kvStore = store;
          // 请确保获取到键值数据库实例后，再进行相关数据操作
        });
    } catch (e) {
      let error = e as BusinessError;
      Logger.error(TAG, `An unexpected error occurred. Code:${error.code},message:${error.message}`);
    }
  }

  deleteAll() {
    this.kvManager?.deleteKVStore(AppUtils.getPackageName(getContext()), KVStoreHelper._default_store_id)
      .then(() => {
        Logger.error(TAG, 'deleteAll success')
      }).catch((e: object) => {
      Logger.error(TAG, 'deleteAll error: ' + JSON.stringify(e))
    })
  }

  private checkStoreCreated() {
    if (!this.kvManager) {
      this.createKVManager()
    }
    if (!this.kvStore) {
      this.createKVStore()
    }
  }

  get(key: string, def: boolean | string | number | Uint8Array): Promise<boolean | string | number | Uint8Array> {
    // this.checkStoreCreated()
    return new Promise<boolean | string | number | Uint8Array>((success, failed) => {
      try {
        this.kvStore?.get(key, (err, data) => {
          if (err != undefined) {
            Logger.debug(TAG, `Failed to get data. Code:${err.code},message:${err.message}`);
            success(def)
            return;
          }
          success(data)
          Logger.debug(TAG, `Succeeded in getting data. Data:${data}`);
        });
      } catch (e) {
        success(def)
        let error = e as BusinessError;
        Logger.error(TAG, `Failed to get data. Code:${error.code},message:${error.message}`);
      }
    });
  }

  put(key: string, value: boolean | string | number | Uint8Array) {
    // this.checkStoreCreated()
    try {
      this.kvStore?.put(key, value, (err) => {
        if (err !== undefined) {
          Logger.debug(TAG, `Failed to put data. Code:${err.code},message:${err.message}`);
          return;
        }
        Logger.debug(TAG, 'Succeeded in putting data.');
      });
    } catch (e) {
      let error = e as BusinessError;
      Logger.error(TAG, `An unexpected error occurred. Code:${error.code},message:${error.message}`);
    }
  }

  del(key: string) {
    // this.checkStoreCreated()
    try {
      this.kvStore?.delete(key, (err) => {
        if (err !== undefined) {
          Logger.debug(TAG, `Failed to delete data. Code:${err.code},message:${err.message}`);
          return;
        }
        Logger.debug(TAG, 'Succeeded in deleting data.');
      });
    } catch (e) {
      let error = e as BusinessError;
      Logger.error(TAG, `An unexpected error occurred. Code:${error.code},message:${error.message}`);
    }
  }
}