/**
 * 在公共文档目录下递归创建多级文件夹
 * @param {*} relativePath
 * @returns
 */
export async function createFolder(relativePath) {
  try {
    // 1. 获取根目录对象（网页1、网页5）
    const rootEntry = await new Promise((resolve, reject) => {
      plus.io.requestFileSystem(plus.io.PUBLIC_DOCUMENTS, resolve, reject);
    }).then((fs) => fs.root);

    // 2. 路径标准化处理（网页5、网页7）
    const pathSegments = relativePath.split("/").filter(Boolean);
    let currentDir = rootEntry;

    // 3. 递归创建目录（网页1、网页5、网页8）
    for (const segment of pathSegments) {
      currentDir = await new Promise((resolve, reject) => {
        currentDir.getDirectory(
          segment,
          { create: false },
          (dir) => resolve(dir), // 目录已存在直接返回（网页7逻辑）
          () =>
            currentDir.getDirectory(
              // 目录不存在时创建（网页5方法）
              segment,
              { create: true },
              resolve,
              reject
            )
        );
      });
    }

    return currentDir;
  } catch (error) {
    console.error(`目录创建失败: ${error.message}`);
    throw new Error(`操作失败: ${error.code}`);
  }
}

/**
 * 复制相册图片
 * @param {*} sourcePath
 * @param {*} targetPath
 * @returns
 */
export async function copyImage(sourcePath, targetPath) {
  try {
    // 1. 处理iOS路径格式问题[1](@ref)
    const normalizedSource = plus.io.convertLocalFileSystemURL(sourcePath);
    const normalizedTarget = plus.io.convertLocalFileSystemURL(targetPath);

    // 2. 解析源文件对象
    const sourceEntry = await new Promise((resolve, reject) => {
      plus.io.resolveLocalFileSystemURL(normalizedSource, resolve, reject);
    });
    if (!sourceEntry.isFile) throw new Error("源路径不是文件");

    // 3. 分解目标路径为目录和文件名
    const targetDirPath = normalizedTarget.substring(
      0,
      normalizedTarget.lastIndexOf("/")
    );
    const targetFileName = normalizedTarget.split("/").pop();

    // 4. 获取目标目录对象
    const targetDirEntry = await new Promise((resolve, reject) => {
      plus.io.resolveLocalFileSystemURL(targetDirPath, resolve, (err) => {
        reject(new Error(`目标目录不存在: ${targetDirPath}`));
      });
    });

    // 5. 执行文件复制
    const newEntry = await new Promise((resolve, reject) => {
      sourceEntry.copyTo(targetDirEntry, targetFileName, resolve, (err) => {
        // 处理文件已存在的覆盖逻辑
        if (err.code === 12) {
          // 文件已存在错误码
          targetDirEntry.getFile(
            targetFileName,
            { create: false },
            (existEntry) =>
              existEntry.remove(() =>
                sourceEntry.copyTo(
                  targetDirEntry,
                  targetFileName,
                  resolve,
                  reject
                )
              ),
            reject
          );
        } else {
          reject(err);
        }
      });
    });

    // 6. 返回标准化路径（移除file://前缀）
    return newEntry.toURL().replace(/^file:\/\//, "");
  } catch (error) {
    console.error(`文件复制失败: ${error.message}`);
    throw new Error(`操作失败: ${error.message}`);
  }
}

/**
 * 从指定文件夹中选取多个文件名并复制到目标目录
 * @param {string} sourceDirectoryPath 源文件夹路径（相对于 PUBLIC_DOCUMENTS 根目录）
 * @param {string} targetDirectoryPath 目标文件夹路径（相对于 PUBLIC_DOCUMENTS 根目录）
 * @param {string[]} fileNames 要复制的文件名列表
 * @returns {Promise<void>} 返回一个 Promise，在复制成功时 resolve，失败时 reject
 */
export function copySelectedFiles(
  sourceDirectoryPath,
  targetDirectoryPath,
  fileNames
) {
  return new Promise((resolve, reject) => {
    // 请求文件系统
    plus.io.requestFileSystem(
      plus.io.PUBLIC_DOCUMENTS,
      (fs) => {
        // 获取源文件夹路径的目录条目
        fs.root.getDirectory(
          sourceDirectoryPath,
          { create: false },
          (sourceDirEntry) => {
            // 获取目标文件夹路径的目录条目
            fs.root.getDirectory(
              targetDirectoryPath,
              { create: true, exclusive: false },
              (targetDirEntry) => {
                // 创建一个空的目录读取器
                const directoryReader = sourceDirEntry.createReader();
                // 读取源目录中的所有文件和子目录
                directoryReader.readEntries(
                  (entries) => {
                    // 筛选出需要复制的文件
                    const filesToCopy = entries.filter(
                      (entry) => entry.isFile && fileNames.includes(entry.name)
                    );

                    // 如果没有匹配的文件，直接返回
                    if (filesToCopy.length === 0) {
                      console.log("没有找到需要复制的文件");
                      return resolve();
                    }

                    let copyCount = 0;
                    // 遍历需要复制的文件
                    filesToCopy.forEach((fileEntry) => {
                      // 复制文件到目标目录
                      fileEntry.copyTo(
                        targetDirEntry,
                        fileEntry.name,
                        () => {
                          ++copyCount;
                          // 如果所有文件都复制完成，则 resolve
                          if (copyCount === filesToCopy.length) {
                            resolve();
                          }
                        },
                        (error) => {
                          console.error(
                            `复制文件失败：${fileEntry.name}, 错误信息：${error.message}`
                          );
                          reject({
                            message: `复制文件失败：${fileEntry.name}`,
                            error,
                          });
                        }
                      );
                    });
                  },
                  (error) => {
                    console.error(
                      `读取目录内容失败：${sourceDirectoryPath}, 错误信息：${error.message}`
                    );
                    reject({
                      message: "读取目录内容失败",
                      error,
                    });
                  }
                );
              },
              (error) => {
                console.error(
                  `获取目标目录失败：${targetDirectoryPath}, 错误信息：${error.message}`
                );
                reject({
                  message: "获取目标目录失败",
                  error,
                });
              }
            );
          },
          (error) => {
            console.error(
              `获取源目录失败：${sourceDirectoryPath}, 错误信息：${error.message}`
            );
            reject({
              message: "获取源目录失败",
              error,
            });
          }
        );
      },
      (error) => {
        console.error(`请求文件系统失败：${error.message}`);
        reject({
          message: "请求文件系统失败",
          error,
        });
      }
    );
  });
}
