// 初始化数据库函数
export async function initDatabase() {
  try {
    const db = await new Promise((resolve, reject) => {
      const request = indexedDB.open("FileDataDB");
      request.onsuccess = (event) => resolve(event.target.result);
      request.onerror = (event) => reject(event.target.error);
    });
    return db;
  } catch (error) {
    console.error("Failed to open IndexedDB:", error);
    return null; // 可以返回默认值，如 null，避免影响页面
  }
}

// 判断是否存在这个数据库及表
export function checkObjectStoreExists(dbName, storeName) {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(dbName);

    request.onsuccess = (event) => {
      const db = event.target.result;
      const storeExists = db.objectStoreNames.contains(storeName);
      db.close();
      resolve(storeExists);
    };

    request.onerror = (event) => {
      console.error("Database open failed:", event.target.error);
      resolve(false); // 错误发生时返回 false，避免影响页面
    };
  });
}

// 获取 IndexedDB 所有数据
export async function getDataFromIndexedDB() {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open("FileDataDB");

    request.onsuccess = (event) => {
      const db = event.target.result;
      const transaction = db.transaction(["files"], "readonly");
      const store = transaction.objectStore("files");

      const getRequest = store.getAll();
      getRequest.onsuccess = () => {
        if (getRequest.result && getRequest.result.length > 0) {
          const fileData = getRequest.result.find(
            (item) => item.id === "fileDataArray"
          );
          resolve(fileData ? fileData.data : []); // 返回文件数据或空数组
        } else {
          resolve([]); // 数据库为空时返回空数组
        }
      };

      getRequest.onerror = (event) => {
        console.error(
          "Failed to retrieve data from IndexedDB:",
          event.target.error
        );
        resolve([]); // 错误发生时返回空数组，避免影响页面展示
      };
    };

    request.onerror = (event) => {
      console.error("Failed to open IndexedDB:", event.target.error);
      resolve([]); // 错误发生时返回空数组
    };
  });
}

// 清除 FileDataDB 整个对象存储
export async function clearAllDataFromIndexedDB() {
  return new Promise((resolve, reject) => {
    const versionRequest = indexedDB.open("FileDataDB");
    versionRequest.onsuccess = (event) => {
      const db = event.target.result;
      if (!db.objectStoreNames.contains("files")) {
        console.log("Object store 'files' does not exist. No action needed.");
        db.close();
        return resolve();
      }
      const currentVersion = db.version;
      db.close();

      const request = indexedDB.open("FileDataDB", currentVersion);
      request.onsuccess = (event) => {
        const db = event.target.result;
        const transaction = db.transaction(["files"], "readwrite");
        const store = transaction.objectStore("files");

        const clearRequest = store.clear();

        clearRequest.onsuccess = () => {
          console.log("All data cleared from IndexedDB.");
          resolve();
        };

        clearRequest.onerror = (event) => {
          console.error(
            "Failed to clear data from IndexedDB:",
            event.target.error
          );
          reject(event.target.error); // 错误发生时拒绝 Promise
        };
      };

      request.onerror = (event) => {
        console.error("Failed to open IndexedDB:", event.target.error);
        reject(event.target.error);
      };
    };

    versionRequest.onerror = (event) => {
      console.error("Failed to retrieve database version:", event.target.error);
      reject(event.target.error);
    };
  });
}

// 清除 myIndexedDB 整个对象存储
export const clearMyIndexedDBIndexedDB = () => {
  const dbName = "myIndexedDB";

  const request = indexedDB.open(dbName);

  request.onsuccess = (event) => {
    const db = event.target.result;
    try {
      const transaction = db.transaction(db.objectStoreNames, "readwrite");
      for (const storeName of db.objectStoreNames) {
        if (storeName.startsWith("vuexData")) {
          const objectStore = transaction.objectStore(storeName);
          objectStore.clear().onsuccess = () => {
            console.log(`Cleared all data in ${storeName}`);
          };
        }
      }
      transaction.oncomplete = () => {
        console.log("All vuexData tables cleared.");
        db.close();
      };
    } catch (e) {
      console.log(e);
    }
  };

  request.onerror = (event) => {
    console.error("Failed to open IndexedDB:", event.target.error);
  };
};

// 往 IndexedDB 某一个表里添加一条数据
export async function storeSetData(db, storeName, key, newFileData, callback) {
  if (!db) {
    console.error("Database is not initialized.");
    return;
  }
  const transaction = db.transaction([storeName], "readwrite");
  const store = transaction.objectStore(storeName);

  const getRequest = store.get(key);
  getRequest.onsuccess = () => {
    const fileDataArray = getRequest.result ? getRequest.result.data : [];
    console.log("Current fileDataArray:", fileDataArray);

    fileDataArray.push(newFileData);

    const putRequest = store.put({
      id: key,
      data: fileDataArray,
    });

    putRequest.onsuccess = () => {
      console.log("Data successfully saved to IndexedDB");
      if (callback && typeof callback === "function") {
        callback();
      }
    };

    putRequest.onerror = (event) => {
      console.error("Error updating data in IndexedDB:", event.target.error);
    };
  };

  getRequest.onerror = (event) => {
    console.error("Error retrieving data from IndexedDB:", event.target.error);
  };
}

// 打开数据库
export async function openDB(dbName, version) {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(dbName, version);
    request.onsuccess = () => resolve(request.result);

    request.onerror = (event) => {
      console.error("Error opening database:", event.target.error);
      reject(event.target.error);
    };

    request.onupgradeneeded = (event) => {
      const db = event.target.result;
      if (!db.objectStoreNames.contains("vuexData")) {
        db.createObjectStore("vuexData", { keyPath: "key" });
      }
    };
  });
}

// 保存数据
export async function saveData(dbName, key, value) {
  const db = await openDB(dbName, 1);
  return new Promise((resolve, reject) => {
    const transaction = db.transaction(["vuexData"], "readwrite");
    const store = transaction.objectStore("vuexData");
    const request = store.put({ key, value });

    request.onsuccess = () => resolve(true);
    request.onerror = (event) => reject(event.target.error);
  });
}

// 获取数据
export async function getData(dbName, key) {
  const db = await openDB(dbName, 1);
  return new Promise((resolve, reject) => {
    const transaction = db.transaction(["vuexData"], "readonly");
    const store = transaction.objectStore("vuexData");
    const request = store.get(key);

    request.onsuccess = () => resolve(request.result?.value || null);
    request.onerror = (event) => reject(event.target.error);
  });
}