export async function readIndexedDB() {
  const databases = await indexedDB.databases();
  const allData = [];

  for (const db of databases) {
    const databaseName = db.name;

    // 打开数据库
    const request = indexedDB.open(databaseName);

    const databaseData = await new Promise((resolve, reject) => {
      request.onsuccess = (event) => {
        const db = event.target.result;
        const transaction = db.transaction(db.objectStoreNames, 'readonly');
        const objectStore = transaction.objectStore(db.objectStoreNames[0]);
        const cursorRequest = objectStore.openCursor();

        const storeData = [];

        cursorRequest.onsuccess = (event) => {
          const cursor = event.target.result;
          if (cursor) {
            storeData.push({ key: cursor.key, value: cursor.value });
            cursor.continue();
          } else {
            resolve(storeData); // 执行 resolve，返回数据
          }
        };

        cursorRequest.onerror = (event) => {
          reject(event.target.error); // 发生错误时 reject
        };
      };

      request.onerror = (event) => {
        reject(event.target.error); // 发生错误时 reject
      };
    });

    // 将数据库数据存入 allData
    allData.push({
      databaseName,
      data: databaseData,
    });
  }

  return allData;
}

export async function writeIndexedDB(jsonData) {
  return new Promise((resolve, reject) => {
    // 使用 async 函数来处理异步操作
    const processDatabase = async (database) => {
      try {
        // 打开 IndexedDB 数据库
        const openRequest = indexedDB.open(database.databaseName, 2);

        // 处理数据库版本升级
        openRequest.onupgradeneeded = (event) => {
          const db = event.target.result;
          // 创建对象存储，如果不存在的话
          if (!db.objectStoreNames.contains('keyvaluepairs')) {
            db.createObjectStore('keyvaluepairs');
          }
          if (!db.objectStoreNames.contains('local-forage-detect-blob-support')) {
            db.createObjectStore('local-forage-detect-blob-support');
          }
        };

        // 处理数据库打开成功
        openRequest.onsuccess = async (event) => {
          const db = event.target.result;
          const table = database.data;
          const transaction = db.transaction(['keyvaluepairs'], 'readwrite');
          const objectStore = transaction.objectStore('keyvaluepairs'); // 使用硬编码的存储名
          console.log(table.value);

          let completedOperations = 0;
          const totalOperations = table.length;

          // 使用 Promise.all 来确保所有的写入操作完成
          const writeOperations = table.map((item, index) => {
            return new Promise((innerResolve, innerReject) => {
              const addObject = objectStore.put(item.value, item.key);
              addObject.onsuccess = () => {
                console.log('数据添加成功', item.key);
                completedOperations++;
                // 如果所有操作完成，调用 resolve
                if (completedOperations === totalOperations) {
                  innerResolve('数据写入成功');
                }
              };
              addObject.onerror = (event) => {
                console.error('数据添加失败:', event.target.error);
                innerReject('数据添加失败');
              };
            });
          });

          // 等待所有写入操作完成
          try {
            await Promise.all(writeOperations);
            console.log('所有数据写入完成');
            resolve('所有数据写入完成');
          } catch (error) {
            reject('数据写入失败');
          }
        };

        // 错误处理
        openRequest.onerror = (event) => {
          console.error('数据库打开失败:', event.target.error);
          reject('数据库打开失败');
        };
      } catch (error) {
        reject('数据库操作失败: ' + error);
      }
    };

    // 遍历所有数据库
    Promise.all(jsonData.map((database) => processDatabase(database)))
      .then(() => resolve('所有数据库操作完成'))
      .catch((error) => reject('操作失败: ' + error));
  });
}