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) => {
        const processDatabase = async (database, objectStoreNames) => {
            try {
                // 动态获取数据库版本号
                const version = database.version || 2;
                const openRequest = indexedDB.open(database.databaseName, version);

                // 处理数据库版本升级
                openRequest.onupgradeneeded = event => {
                    const db = event.target.result;
                    objectStoreNames.forEach(storeName => {
                        if (!db.objectStoreNames.contains(storeName)) {
                            db.createObjectStore(storeName);
                        }
                    });
                };

                // 处理数据库打开成功
                openRequest.onsuccess = async event => {
                    const db = event.target.result;
                    const table = database.data;
                    const transaction = db.transaction(objectStoreNames, 'readwrite');
                    const objectStore = transaction.objectStore(objectStoreNames[0]);

                    // 添加事务错误处理
                    transaction.onerror = event => {
                        console.error('事务失败:', event.target.error);
                        reject('事务失败');
                    };

                    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 = () => {
                                completedOperations++;
                                if (completedOperations === totalOperations) {
                                    innerResolve('数据写入成功');
                                }
                            };
                            addObject.onerror = event => {
                                console.error('数据添加失败:', event.target.error);
                                innerReject('数据添加失败');
                            };
                        });
                    });

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

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

        // 遍历所有数据库
        const objectStoreNames = ['keyvaluepairs', 'local-forage-detect-blob-support'];
        Promise.all(jsonData.map(database => processDatabase(database, objectStoreNames)))
            .then(() => resolve('所有数据库操作完成'))
            .catch(error => reject('操作失败: ' + error));
    });
}