import * as plugins from './npmextra.plugins.js';
import * as paths from './npmextra.paths.js';
import { KeyValueStore } from './npmextra.classes.keyvaluestore.js';
import { env } from 'process';

export interface IAppDataOptions {
  dirPath?: string;
  requiredKeys?: string[];

  /**
   * kvStoreKey: 'MY_ENV_VAR'
   */
  envMapping?: {
    [key: string]: string;
  };
}

export class AppData {
  /**
   * creates appdata. If no pathArg is given, data will be stored here:
   * ${PWD}/.nogit/appdata
   * @param pathArg
   * @returns
   */
  public static async createAndInit(optionsArg: IAppDataOptions = {}) {
    const appData = new AppData(optionsArg);
    await appData.readyDeferred.promise;
    return appData;
  }

  // instance
  public readyDeferred = plugins.smartpromise.defer();
  public options: IAppDataOptions;
  private kvStore: KeyValueStore;
  constructor(optionsArg: IAppDataOptions = {}) {
    this.options = optionsArg;
    this.init();
  }

  /**
   * inits app data
   * @param pathArg
   */
  private async init(pathArg?: string) {
    if (this.options.dirPath) {
      // ok, nothing to do here;
    } else {
      const appDataDir = '/app/data';
      const dataDir = '/data';
      const nogitAppData = '.nogit/appdata';
      const appDataExists = plugins.smartfile.fs.isDirectory(appDataDir);
      const dataExists = plugins.smartfile.fs.isDirectory(dataDir);
      if (appDataExists) {
        this.options.dirPath = appDataDir;
      } else if (dataExists) {
        this.options.dirPath = dataDir;
      } else {
        await plugins.smartfile.fs.ensureDir(nogitAppData);
        this.options.dirPath = nogitAppData;
      }
    }
    this.kvStore = new KeyValueStore({
      typeArg: 'custom',
      identityArg: 'appkv',
      customPath: this.options.dirPath,
      mandatoryKeys: this.options.requiredKeys
    });

    if (this.options.envMapping) {
      const qenvInstance = new plugins.qenv.Qenv(process.cwd(), '~/.cloudlyrc');
      for (const key in this.options.envMapping) {
        let envValue = await qenvInstance.getEnvVarOnDemand(key);
        if (envValue) {
          if (key.endsWith('_JSON')) {
            envValue = JSON.parse(envValue);
          }
          await this.kvStore.writeKey(key, envValue);
        }
      }
    }

    this.readyDeferred.resolve();
  }

  /**
   * returns a kvtore that resides in appdata
   */
  public async getKvStore() {
    await this.readyDeferred.promise;
    return this.kvStore;
  }

  public async logMissingKeys() {
    const kvStore = await this.getKvStore();
    const missingMandatoryKeys = kvStore.getMissingMandatoryKeys();
    if (missingMandatoryKeys.length > 0) {
      console.log(
        `The following mandatory keys are missing in the appdata:\n   -> ${missingMandatoryKeys.join(
          ',\n   -> '
        )}`
      );
    } else {
      console.log('All mandatory keys are present in the appdata');
    }
  }

  public async waitForAndGetKey(keyArg: string) {
    await this.readyDeferred.promise;
    await this.kvStore.waitForKeysPresent([keyArg]);
    return this.kvStore.readKey[keyArg];
  }
}