// 从主题配置中获取远程封面相关参数

  const themeConfig = hexo.theme.config;

  const coverMap = themeConfig.cover_map || {};

  const imgbed = themeConfig.imgbed || "";

  if (categories && categories.length) {

    categories.forEach((cat) => {

      // 优先判断 cover_map 配置

      if (coverMap[cat.slug]) {

        // 使用远程封面链接

        cat.cover = imgbed + coverMap[cat.slug];

        // 处理分类的归属关系及子分类 / 文章数据（与本地封面处理逻辑一致）

        const topcat = getTopcat(cat);

        if (topcat._id !== cat._id) {

          cat.top = topcat;

        }

        const child = categories.find({ parent: cat._id });

        let pl = 6;

        if (child.length !== 0) {

          cat.child = child.length;

          cat.subs = child.sort({ name: 1 }).limit(6).toArray();

          pl = Math.max(0, pl - child.length);

          if (pl > 0) {

            cat.subs.push(...cat.posts.sort({ title: 1 }).filter(function(item, i) {

              return item.categories.last()._id === cat._id;

            }).limit(pl).toArray());

          }

        } else {

          cat.subs = cat.posts.sort({ title: 1 }).limit(6).toArray();

        }

        catlist.push(cat);

      } else {

        // 没有配置 cover_map，则使用本地封面图片

        const localCoverDir = `source/_posts/${cat.slug}`;

        if (fs.existsSync(localCoverDir + "/cover.avif")) {

          covers.push({

            path: cat.slug + "/cover.avif",

            data: function() {

              return fs.createReadStream(localCoverDir + "/cover.avif");

            }

          });

        } else if (fs.existsSync(localCoverDir + "/cover.webp")) {

          covers.push({

            path: cat.slug + "/cover.webp",

            data: function() {

              return fs.createReadStream(localCoverDir + "/cover.webp");

            }

          });

        } else if (fs.existsSync(localCoverDir + "/cover.jpg")) {

          covers.push({

            path: cat.slug + "/cover.jpg",

            data: function() {

              return fs.createReadStream(localCoverDir + "/cover.jpg");

            }

          });

          const topcat = getTopcat(cat);

          if (topcat._id !== cat._id) {

            cat.top = topcat;

          }

          const child = categories.find({ parent: cat._id });

          let pl = 6;

          if (child.length !== 0) {

            cat.child = child.length;

            cat.subs = child.sort({ name: 1 }).limit(6).toArray();

            pl = Math.max(0, pl - child.length);

            if (pl > 0) {

              cat.subs.push(...cat.posts.sort({ title: 1 }).filter(function(item, i) {

                return item.categories.last()._id === cat._id;

              }).limit(pl).toArray());

            }

          } else {

            cat.subs = cat.posts.sort({ title: 1 }).limit(6).toArray();

          }

          catlist.push(cat);

        }

      }

    });

  }

if (categories && categories.length) {

    categories.forEach((cat) => {

      const cover = `source/_posts/${cat.slug}`;

      if (fs.existsSync(cover + "/cover.avif")) {

        covers.push({

          path: cat.slug + "/cover.avif",

          data: function() {

            return fs.createReadStream(cover + "/cover.avif");

          }

        });

      } else if (fs.existsSync(cover + "/cover.webp")) {

        covers.push({

          path: cat.slug + "/cover.webp",

          data: function() {

            return fs.createReadStream(cover + "/cover.webp");

          }

        });

      } else if (fs.existsSync(cover + "/cover.jpg")) {

        covers.push({

          path: cat.slug + "/cover.jpg",

          data: function() {

            return fs.createReadStream(cover + "/cover.jpg");

          }

        });

        const topcat = getTopcat(cat);

        if (topcat._id !== cat._id) {

          cat.top = topcat;

        }

        const child = categories.find({ parent: cat._id });

        let pl = 6;

        if (child.length !== 0) {

          cat.child = child.length;

          cat.subs = child.sort({ name: 1 }).limit(6).toArray();

          pl = Math.max(0, pl - child.length);

          if (pl > 0) {

            cat.subs.push(...cat.posts.sort({ title: 1 }).filter(function(item, i) {

              return item.categories.last()._id === cat._id;

            }).limit(pl).toArray());

          }

        } else {

          cat.subs = cat.posts.sort({ title: 1 }).limit(6).toArray();

        }

        catlist.push(cat);

      }

    });

  }

const fs = require("fs");

const path = require("path");

const yaml = require("js-yaml");

// JSON 文件路径

const jsonFilePath = path.join(__dirname, "themes/shokaX/images.json");

// YAML 文件路径（用于生成首页与文章图片列表）

const indexYmlPath = path.join(__dirname, "themes/shokaX/_images_index.yml");

const articleYmlPath = path.join(__dirname, "themes/shokaX/_images.yml");

// 主题图片文件夹路径（本地封面备用）

const coverImgDir = path.join(__dirname, "source/_data/coverimg");

// 博客文章文件夹路径

const postsDir = path.join(__dirname, "source/_posts");

// 主题配置文件路径

const configFilePath = path.join(__dirname, "_config.shokaX.yml");

/**

 * 组合 imgbed URL 与 imageName，若 imageName 已为完整 URL 则直接返回

 */

const getFullImageUrl = (imgbed, imageName) => {

  return /^https?:\/\//.test(imageName) ? imageName : `${imgbed}${imageName}`;

};

/**

 * 随机从数组中选取 n 个元素（不保证原数组顺序）

 */

const getRandomElements = (array, n) => {

  const shuffled = array.sort(() => 0.5 - Math.random());

  return shuffled.slice(0, n);

};

const updateYmlFiles = async () => {

  // 读取 _config.shokaX.yml 配置

  let config;

  try {

    config = yaml.load(fs.readFileSync(configFilePath, "utf8"));

  } catch (error) {

    console.error("Error reading _config.shokaX.yml:", error);

    return;

  }

  // 获取 imgbed 参数

  const imgbed = config.imgbed || "";

  console.log("imgbed:", imgbed);

  // 获取 MyTheme 参数（若为 default 则根据日期选取一个主题）

  let theme = config.MyTheme || "default";

  if (theme === "default") {

    const themes = ["kon", "sp", "eva", "ghibli"];

    const currentDate = new Date();

    // 转换为北京时间

    const beijingTime = new Date(currentDate.getTime() + 8 * 60 * 60 * 1000);

    const dayOfYear = (date) => {

      const start = new Date(date.getFullYear(), 0, 0);

      const diff = date - start + (start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000;

      const oneDay = 1000 * 60 * 60 * 24;

      return Math.floor(diff / oneDay);

    };

    const dayIndex = dayOfYear(beijingTime);

    const themeIndex = dayIndex % themes.length;

    theme = themes[themeIndex];

  }

  console.log("Selected Theme:", theme);

  // 读取 images.json 数据

  const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8"));

  // 生成首页 (home) 与文章 (articles) 图片列表（拼接 imgbed URL）

  const homeImages = (jsonData[theme]?.home || []).map((img) => getFullImageUrl(imgbed, img));

  const articleImages = (jsonData[theme]?.articles || []).map((img) => getFullImageUrl(imgbed, img));

  // 写入 YAML 文件

  fs.writeFileSync(indexYmlPath, homeImages.map((url) => `- ${url}`).join("\n"), "utf8");

  fs.writeFileSync(articleYmlPath, articleImages.map((url) => `- ${url}`).join("\n"), "utf8");

  console.log(`YAML files updated for theme: ${theme}`);

  // 获取本地封面图片（备用方案）所在目录

  const themeCoverDir = path.join(coverImgDir, theme);

  let themeImages = [];

  if (fs.existsSync(themeCoverDir)) {

    themeImages = fs.readdirSync(themeCoverDir).filter((file) => /\.(jpg|jpeg|png|webp)$/i.test(file));

  } else {

    console.error(`Theme folder not found: ${themeCoverDir}`);

  }

  if (themeImages.length === 0) {

    console.error(`No images found in theme folder: ${themeCoverDir}`);

  }

  // 获取博客文章文件夹（每个分类文件夹）

  const postFolders = fs.readdirSync(postsDir).filter((item) => {

    const itemPath = path.join(postsDir, item);

    return fs.statSync(itemPath).isDirectory();

  });

  /**

   * 当 _config.shokaX.yml 中配置了 cover_map 时，

   * 则从 images.json 对应主题下的 cover 数组中随机选取且不重复的图片，

   * 用于更新 cover_map 中各分类的封面值；

   * 同时，对于 cover_map 中已定义的分类，不再生成本地 cover.jpg，

   * 其他分类仍保持原来的随机复制方式。

   */

  if (config.cover_map && Object.keys(config.cover_map).length > 0) {

    const coverMapKeys = Object.keys(config.cover_map);

    // 读取 images.json 中远程封面图片数组

    const coverImagesRemote = jsonData[theme]?.cover || [];

    if (coverImagesRemote.length < coverMapKeys.length) {

      console.error(`Not enough remote cover images available for cover_map assignment for theme: ${theme}`);

    } else {

      // 随机选取不重复的图片赋值给 cover_map 中的每个分类（键）

      const shuffled = coverImagesRemote.sort(() => 0.5 - Math.random());

      coverMapKeys.forEach((key, index) => {

        config.cover_map[key] = shuffled[index];

      });

      // 将更新后的 cover_map 写回 _config.shokaX.yml 文件

      fs.writeFileSync(configFilePath, yaml.dump(config), "utf8");

      console.log("Updated cover_map in _config.shokaX.yml:", config.cover_map);

    }

    // 对于本地封面复制，只处理不在 cover_map 中的分类文件夹

    const localFolders = postFolders.filter(folder => !coverMapKeys.includes(folder));

    if (localFolders.length > 0 && themeImages.length > 0) {

      const selectedImages = getRandomElements(themeImages, localFolders.length);

      localFolders.forEach((folder, index) => {

        const postFolderPath = path.join(postsDir, folder);

        const sourceImagePath = path.join(themeCoverDir, selectedImages[index]);

        const outputImagePath = path.join(postFolderPath, "cover.jpg");

        fs.copyFileSync(sourceImagePath, outputImagePath);

        console.log(`cover.jpg created for ${folder}`);

      });

    }

  } else {

    // 若未配置 cover_map，则使用原来的方式，为所有分类文件夹随机复制本地封面图片

    if (themeImages.length > 0) {

      const selectedImages = getRandomElements(themeImages, postFolders.length);

      postFolders.forEach((folder, index) => {

        const postFolderPath = path.join(postsDir, folder);

        const sourceImagePath = path.join(themeCoverDir, selectedImages[index]);

        const outputImagePath = path.join(postFolderPath, "cover.jpg");

        fs.copyFileSync(sourceImagePath, outputImagePath);

        console.log(`cover.jpg created for ${folder}`);

      });

    }

  }

};

updateYmlFiles();

const fs = require("fs");

const path = require("path");

const yaml = require("js-yaml");

// JSON 文件路径

const jsonFilePath = path.join(__dirname, "themes/shokaX/images.json");

// YAML 文件路径

const indexYmlPath = path.join(__dirname, "themes/shokaX/_images_index.yml");

const articleYmlPath = path.join(__dirname, "themes/shokaX/_images.yml");

// 主题图片文件夹路径

const coverImgDir = path.join(__dirname, "source/_data/coverimg");

// 博客文章文件夹路径

const postsDir = path.join(__dirname, "source/_posts");

// 主题配置文件路径

const configFilePath = path.join(__dirname, "_config.shokaX.yml");

// 读取 `_config.shokaX.yml` 并获取 `imgbed` 参数

const getImgBedUrl = () => {

  try {

    const config = yaml.load(fs.readFileSync(configFilePath, "utf8"));

    return config.imgbed || ""; // 如果 `imgbed` 没有配置，返回空字符串

  } catch (error) {

    console.error("Error reading _config.shokaX.yml:", error);

    return "";

  }

};

// 读取 `_config.shokaX.yml` 并获取 `MyTheme` 参数

const getTheme = () => {

  try {

    const config = yaml.load(fs.readFileSync(configFilePath, "utf8"));

    return config.MyTheme || "default"; // 如果 `imgbed` 没有配置，返回空字符串

  } catch (error) {

    console.error("Error reading theme config:", error);

    return "default";

  }

};

//// 获取当前主题逻辑

// const getTheme = () => {

//   try {

//     const config = fs.readFileSync(configFilePath, "utf8");

//     const match = config.match(/MyTheme:\s*(\S+)/);

//     return match ? match[1] : "default";

//   } catch (error) {

//     console.error("Error reading theme config:", error);

//     return "default";

//   }

// };

// 组合 `imgbed` URL 和 `imageName`

const getFullImageUrl = (imgbed, imageName) => {

  return /^https?:\/\//.test(imageName) ? imageName : `${imgbed}${imageName}`;

};

// 随机从数组中选取 n 个元素

const getRandomElements = (array, n) => {

  const shuffled = array.sort(() => 0.5 - Math.random());

  return shuffled.slice(0, n);

};

// 更新 YAML 文件

const updateYmlFiles = async () => {

  const imgbed = getImgBedUrl(); // 获取 `imgbed` 配置

  console.log("imgbed:", imgbed);

  const theme = getTheme(); // 获取当前主题

  const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8"));

  let selectedTheme = theme;

  if (theme === "default") {

    const themes = ["kon", "sp", "eva", "ghibli"];

    const currentDate = new Date();

    const beijingTime = new Date(currentDate.getTime() + 8 * 60 * 60 * 1000); // 转换为北京时间

    // 根据日期计算主题索引

    const dayOfYear = (date) => {

      const start = new Date(date.getFullYear(), 0, 0);

      const diff = date - start + (start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000;

      const oneDay = 1000 * 60 * 60 * 24;

      return Math.floor(diff / oneDay);

    };

    const dayIndex = dayOfYear(beijingTime);

    const themeIndex = dayIndex % themes.length;

    selectedTheme = themes[themeIndex];

  }

  console.log("Selected Theme:", selectedTheme);

  // 获取 `home` 和 `articles` 图片，并拼接 `imgbed`

  const homeImages = (jsonData[selectedTheme]?.home || []).map((img) => getFullImageUrl(imgbed, img));

  const articleImages = (jsonData[selectedTheme]?.articles || []).map((img) => getFullImageUrl(imgbed, img));

  // 写入 YAML 文件

  fs.writeFileSync(indexYmlPath, homeImages.map((url) => `- ${url}`).join("\n"), "utf8");

  fs.writeFileSync(articleYmlPath, articleImages.map((url) => `- ${url}`).join("\n"), "utf8");

  console.log(`YAML files updated for theme: ${selectedTheme}`);

  // 获取主题对应的图片文件夹

  const themeCoverDir = path.join(coverImgDir, selectedTheme);

  if (!fs.existsSync(themeCoverDir)) {

    console.error(`Theme folder not found: ${themeCoverDir}`);

    return;

  }

  // 获取主题图片列表

  const themeImages = fs.readdirSync(themeCoverDir).filter((file) => /\.(jpg|jpeg|png|webp)$/i.test(file));

  if (themeImages.length === 0) {

    console.error(`No images found in theme folder: ${themeCoverDir}`);

    return;

  }

  // 获取博客文章文件夹数量

  const postFolders = fs.readdirSync(postsDir).filter((item) => {

    const itemPath = path.join(postsDir, item);

    return fs.statSync(itemPath).isDirectory();

  });

  // 随机选取图片并生成 cover.jpg

  const selectedImages = getRandomElements(themeImages, postFolders.length);

  postFolders.forEach((folder, index) => {

    const postFolderPath = path.join(postsDir, folder);

    const sourceImagePath = path.join(themeCoverDir, selectedImages[index]);

    const outputImagePath = path.join(postFolderPath, "cover.jpg");

    // 复制图片为 cover.jpg

    fs.copyFileSync(sourceImagePath, outputImagePath);

    console.log(`cover.jpg created for ${folder}`);

  });

};

updateYmlFiles();

hexo.extend.helper.register("_image_url", function(img, path = "") {

  const { statics, imgbed } = hexo.theme.config;

  const { post_asset_folder } = hexo.config;

  if (img.startsWith("//") || img.startsWith("http")) {

    return img;

  } else if (imgbed && imgbed.trim() !== "") {

    // 如果配置了 imgbed，则使用它拼接完整的 URL

    const base = imgbed.endsWith('/') ? imgbed : imgbed + '/';

    return base + img;

  } else {

    return import_hexo_util.url_for.call(this, statics + (post_asset_folder ? path : "") + img);

  }

});

hexo.extend.helper.register("_image_url", function(img, path = "") {

  const { statics } = hexo.theme.config;

  const { post_asset_folder } = hexo.config;

  if (img.startsWith("//") || img.startsWith("http")) {

    return img;

  } else {

    return import_hexo_util.url_for.call(this, statics + (post_asset_folder ? path : "") + img);

  }

});