import {timestamp} from '@caj/configs/types';
import MyUserManager from '@caj/user/MyUserManager';
import {IDBPDatabase, openDB} from 'idb';
import {databaseConfType} from './schemas';
import {
  databaseConf,
  databaseNames,
  databaseNameSuffix,
  mergeDBName,
} from './types';

const closeTimeout = 5; // in seconds // when DB read/writes is too long in idle it will be closed

type DBType = IDBPDatabase<unknown>;

export interface DBObject {
  name: databaseNames;
  schema: databaseConfType;
  db: DBType | undefined;
  lastUsedTimestamp?: timestamp; // when timeout is undefined then db is closed
}

export type DBs = {[key: string]: DBObject};
export let databases: DBs = {};

function getTime() {
  return Math.floor(new Date().getTime() / 1000);
}

setInterval(() => {
  const curTime = getTime();

  for (let name in databases) {
    let dbObj = databases[name];

    if (
      dbObj.lastUsedTimestamp !== undefined &&
      dbObj.lastUsedTimestamp + closeTimeout < curTime
    ) {
      dbObj.db?.close();
      dbObj.lastUsedTimestamp = undefined;
      console.log('Database not used. Closing ' + dbObj.name);
    }
  }
}, 5000);

export function closeAllDatabases() {
  for (let name in databases) {
    let dbObj = databases[name];

    if (dbObj.lastUsedTimestamp !== undefined) {
      dbObj.db?.close();
      dbObj.lastUsedTimestamp = undefined;
    }
  }
}

export async function openMyDatabase(
  schema: databaseConfType,
  nameObj: databaseNameSuffix,
): Promise<DBType> {
  const db = await openDB(mergeDBName(nameObj, 'web'), schema.version, {
    upgrade: schema.migration(),
  });

  /*if (init === true) {
    const UserId = MyUserManager.getSelectedUserId();
    console.log(db.objectStoreNames.contains(UserId));
    if (db.objectStoreNames.contains(UserId) === false) {
    }
  }*/

  return db;
}

export async function getDatabase(
  _name: databaseNameSuffix,
  init?: boolean,
): Promise<DBType> {
  const name = mergeDBName(_name);
  let dbObj = databases[name];

  if (dbObj !== undefined) {
    if (dbObj.lastUsedTimestamp !== undefined && dbObj.db !== undefined) {
      dbObj.lastUsedTimestamp = getTime();

      if (init === true) {
        dbObj.db.close();

        dbObj.lastUsedTimestamp = undefined;
        const db = await openMyDatabase(dbObj.schema /*, init*/, _name);
        dbObj.lastUsedTimestamp = getTime();

        dbObj.db = db;

        return db;
      } else {
        return dbObj.db;
      }
    } else {
      dbObj.lastUsedTimestamp = undefined;
      const db = await openMyDatabase(dbObj.schema /*, init*/, _name);
      dbObj.lastUsedTimestamp = getTime();
      dbObj.db = db;
      return db;
    }
  } else {
    throw "Database '" + name + "' is not initialized";
  }
}