(() => {
  function openDatabase(cacheConfig) {
    return new Promise((resolve, reject) => {
      if (!globalThis.indexedDB) {
        reject(new Error("IndexedDB is not available in this browser context."));
        return;
      }

      const request = globalThis.indexedDB.open(
        cacheConfig.dbName,
        cacheConfig.dbVersion
      );

      request.onupgradeneeded = () => {
        const database = request.result;

        if (!database.objectStoreNames.contains(cacheConfig.storeName)) {
          database.createObjectStore(cacheConfig.storeName, { keyPath: "key" });
        }
      };

      request.onsuccess = () => {
        resolve(request.result);
      };

      request.onerror = () => {
        reject(request.error || new Error("Unable to open IndexedDB cache."));
      };
    });
  }

  async function withStore(cacheConfig, mode, callback) {
    const database = await openDatabase(cacheConfig);

    return new Promise((resolve, reject) => {
      const transaction = database.transaction(cacheConfig.storeName, mode);
      const store = transaction.objectStore(cacheConfig.storeName);

      transaction.oncomplete = () => {
        database.close();
      };

      transaction.onerror = () => {
        const error =
          transaction.error || new Error("IndexedDB transaction failed.");
        database.close();
        reject(error);
      };

      transaction.onabort = () => {
        const error =
          transaction.error || new Error("IndexedDB transaction was aborted.");
        database.close();
        reject(error);
      };

      callback(store, resolve, reject);
    });
  }

  function readRecord(cacheConfig, key, errorMessage) {
    return withStore(cacheConfig, "readonly", (store, resolve, reject) => {
      const request = store.get(key);

      request.onsuccess = () => {
        resolve(request.result || null);
      };

      request.onerror = () => {
        reject(request.error || new Error(errorMessage || "Unable to read cache."));
      };
    });
  }

  function writeRecord(cacheConfig, record, errorMessage) {
    return withStore(cacheConfig, "readwrite", (store, resolve, reject) => {
      const request = store.put(record);

      request.onsuccess = () => {
        resolve();
      };

      request.onerror = () => {
        reject(request.error || new Error(errorMessage || "Unable to write cache."));
      };
    });
  }

  globalThis.ArchPanelStorageService = Object.freeze({
    openDatabase,
    withStore,
    readRecord,
    writeRecord,
  });
})();