console.log('Hello Hexo');

// 如果文章包含代码示例，务必测试运行
// 示例：验证 Hexo 插件代码

// 1. 创建测试文件
// 2. 运行代码
// 3. 检查输出结果
// 4. 修正错误

// scripts/auto-category.js
// 根据标签自动设置分类的 Hexo 插件

const tagToCategoryMap = {
  '前端': '前端开发',
  '后端': '后端开发',
  'AI': 'AI工具',
  '工具': '工具教程',
  '教程': '技术教程',
  'Node.js': '后端开发',
  'React': '前端开发',
  'Vue': '前端开发'
};

hexo.extend.filter.register('before_post_render', function(data) {
  // 如果文章已有分类，不自动设置
  if (data.categories && data.categories.length > 0) {
    return data;
  }

  // 根据标签自动设置分类
  if (data.tags && data.tags.length > 0) {
    const autoCategories = [];
    
    data.tags.forEach(tag => {
      const tagName = typeof tag === 'string' ? tag : tag.name;
      if (tagToCategoryMap[tagName]) {
        const category = tagToCategoryMap[tagName];
        if (!autoCategories.includes(category)) {
          autoCategories.push(category);
        }
      }
    });

    if (autoCategories.length > 0) {
      data.categories = autoCategories;
    }
  }

  return data;
});

// scripts/auto-excerpt.js
// 自动生成文章摘要的 Hexo 插件

function extractExcerpt(content, maxLength = 150) {
  // 移除代码块
  content = content.replace(/```[\s\S]*?```/g, '');
  // 移除行内代码
  content = content.replace(/`[^`]+`/g, '');
  // 移除链接
  content = content.replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1');
  // 移除图片
  content = content.replace(/!\[([^\]]*)\]\([^\)]+\)/g, '');
  // 移除标题标记
  content = content.replace(/^#+\s+/gm, '');
  // 移除多余空白
  content = content.replace(/\s+/g, ' ').trim();
  
  if (content.length <= maxLength) {
    return content;
  }
  
  // 在最后一个完整句子处截断
  const truncated = content.substring(0, maxLength);
  const lastPeriod = truncated.lastIndexOf('。');
  const lastPeriodEn = truncated.lastIndexOf('.');
  const lastIndex = Math.max(lastPeriod, lastPeriodEn);
  
  if (lastIndex > maxLength * 0.7) {
    return truncated.substring(0, lastIndex + 1);
  }
  
  return truncated + '...';
}

hexo.extend.filter.register('before_post_render', function(data) {
  // 如果已有 description，跳过
  if (data.description && data.description.trim()) {
    return data;
  }

  // 从内容中提取摘要
  if (data.content) {
    data.description = extractExcerpt(data.content);
  }

  return data;
});

// scripts/optimize-images.js
// 图片优化脚本（需要安装 sharp: npm install sharp --save-dev）

const sharp = require('sharp');
const fs = require('fs').promises;
const path = require('path');
const glob = require('glob');

async function optimizeImage(imagePath) {
  const ext = path.extname(imagePath).toLowerCase();
  const nameWithoutExt = path.basename(imagePath, ext);
  const dir = path.dirname(imagePath);
  
  try {
    const image = sharp(imagePath);
    const metadata = await image.metadata();
    
    // 生成 WebP 版本
    const webpPath = path.join(dir, `${nameWithoutExt}.webp`);
    await image
      .webp({ quality: 80 })
      .toFile(webpPath);
    
    // 压缩原图（如果是 JPG）
    if (ext === '.jpg' || ext === '.jpeg') {
      await image
        .jpeg({ quality: 85, mozjpeg: true })
        .toFile(imagePath);
    } else if (ext === '.png') {
      await image
        .png({ quality: 85, compressionLevel: 9 })
        .toFile(imagePath);
    }
    
    console.log(`优化完成: ${imagePath}`);
    return {
      original: imagePath,
      webp: webpPath,
      width: metadata.width,
      height: metadata.height,
      size: metadata.size
    };
  } catch (error) {
    console.error(`优化失败 ${imagePath}:`, error);
    return null;
  }
}

async function optimizeAllImages() {
  const imagePatterns = [
    'source/images/**/*.{jpg,jpeg,png}',
    'source/_posts/**/*.{jpg,jpeg,png}'
  ];
  
  let allImages = [];
  for (const pattern of imagePatterns) {
    const images = glob.sync(pattern);
    allImages = allImages.concat(images);
  }
  
  console.log(`找到 ${allImages.length} 张图片`);
  
  for (const imagePath of allImages) {
    await optimizeImage(imagePath);
  }
  
  console.log('所有图片优化完成！');
}

// 运行脚本
if (require.main === module) {
  optimizeAllImages().catch(console.error);
}

module.exports = { optimizeImage, optimizeAllImages };

// 提示词：为 Hexo 主题添加暗色模式切换功能
// Cursor 可以生成完整的主题定制代码

// themes/your-theme/layout/_partial/theme-switcher.ejs
<button id="theme-toggle" class="theme-toggle">
  <span class="icon">🌙</span>
</button>

<script>
  // Cursor 生成的暗色模式切换逻辑
  const themeToggle = document.getElementById('theme-toggle');
  // ... 完整的实现代码
</script>

// scripts/new-post.js
// Hexo 文章模板生成脚本

const fs = require('fs');
const path = require('path');
const readline = require('readline');
const { exec } = require('child_process');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function question(query) {
  return new Promise(resolve => rl.question(query, resolve));
}

function formatTitle(title) {
  return title
    .toLowerCase()
    .replace(/[^\w\s-]/g, '')
    .replace(/\s+/g, '-')
    .replace(/-+/g, '-')
    .trim();
}

function getTemplate(type) {
  const templates = {
    tutorial: `---
title: {title}
date: {date}
tags: []
categories:
  - {category}
description: 
---

## 简介

## 前置要求

## 使用步骤

### 1. 

### 2. 

## 注意事项

## 总结
`,
    tool: `---
title: {title}
date: {date}
tags: []
categories:
  - {category}
description: 
---

## 简介

## 核心功能

## 使用场景

## 安装和配置

## 使用示例

## 优缺点分析

## 总结
`,
    comparison: `---
title: {title}
date: {date}
tags: []
categories:
  - {category}
description: 
---

## 简介

## 对比维度

## 详细对比

### 功能对比

### 性能对比

### 生态对比

## 使用场景建议

## 总结
`,
    default: `---
title: {title}
date: {date}
tags: []
categories:
  - {category}
description: 
---

## 简介

## 正文内容

## 总结
`
  };
  
  return templates[type] || templates.default;
}

async function createPost() {
  try {
    console.log('=== Hexo 文章模板生成器 ===\n');
    
    // 获取文章信息
    const title = await question('文章标题: ');
    const category = await question('分类 (默认: 未分类): ') || '未分类';
    const tagsInput = await question('标签 (用逗号分隔): ');
    const type = await question('文章类型 (tutorial/tool/comparison/default): ') || 'default';
    const description = await question('描述 (可选): ') || '';
    
    // 处理标签
    const tags = tagsInput
      ? tagsInput.split(',').map(tag => tag.trim()).filter(Boolean)
      : [];
    
    // 生成文件名
    const now = new Date();
    const dateStr = now.toISOString().split('T')[0];
    const fileName = `${dateStr}-${formatTitle(title)}.md`;
    const filePath = path.join(process.cwd(), 'source', '_posts', fileName);
    
    // 检查文件是否已存在
    if (fs.existsSync(filePath)) {
      const overwrite = await question(`文件已存在，是否覆盖? (y/N): `);
      if (overwrite.toLowerCase() !== 'y') {
        console.log('已取消创建');
        rl.close();
        return;
      }
    }
    
    // 生成 Front-matter
    const dateTime = now.toISOString().replace('T', ' ').substring(0, 19);
    const template = getTemplate(type);
    
    let content = template
      .replace(/{title}/g, title)
      .replace(/{date}/g, dateTime)
      .replace(/{category}/g, category);
    
    // 添加标签和描述
    const frontMatterEnd = content.indexOf('---', 3);
    if (frontMatterEnd !== -1) {
      let frontMatter = content.substring(0, frontMatterEnd + 3);
      const body = content.substring(frontMatterEnd + 3);
      
      // 添加标签
      if (tags.length > 0) {
        frontMatter = frontMatter.replace(
          'tags: []',
          `tags:\n${tags.map(tag => `  - ${tag}`).join('\n')}`
        );
      }
      
      // 添加描述
      if (description) {
        frontMatter = frontMatter.replace(
          'description: ',
          `description: ${description}`
        );
      }
      
      content = frontMatter + body;
    }
    
    // 写入文件
    fs.writeFileSync(filePath, content, 'utf8');
    console.log(`\n✅ 文章已创建: ${filePath}`);
    
    // 询问是否打开文件
    const open = await question('是否在编辑器中打开? (Y/n): ');
    if (open.toLowerCase() !== 'n') {
      // 尝试使用系统默认编辑器打开
      const editor = process.env.EDITOR || 'code'; // 默认使用 VS Code
      exec(`${editor} "${filePath}"`, (error) => {
        if (error) {
          console.log(`无法自动打开文件，请手动打开: ${filePath}`);
        }
      });
    }
    
  } catch (error) {
    console.error('创建文章时出错:', error);
  } finally {
    rl.close();
  }
}

// 运行脚本
if (require.main === module) {
  createPost();
}

module.exports = { createPost, formatTitle, getTemplate };

// scripts/analyze-blog.js
// 博客数据分析脚本

const fs = require('fs');
const path = require('path');
const matter = require('gray-matter');

function analyzeBlog() {
  const postsDir = path.join(process.cwd(), 'source', '_posts');
  const files = fs.readdirSync(postsDir).filter(file => file.endsWith('.md'));
  
  const stats = {
    totalPosts: 0,
    categories: {},
    tags: {},
    postsByYear: {},
    postsByMonth: {},
    recentPosts: [],
    longestPosts: [],
    shortestPosts: []
  };
  
  const posts = [];
  
  files.forEach(file => {
    const filePath = path.join(postsDir, file);
    const content = fs.readFileSync(filePath, 'utf8');
    const { data: frontMatter, content: body } = matter(content);
    
    stats.totalPosts++;
    
    // 统计分类
    if (frontMatter.categories) {
      const categories = Array.isArray(frontMatter.categories) 
        ? frontMatter.categories 
        : [frontMatter.categories];
      categories.forEach(cat => {
        stats.categories[cat] = (stats.categories[cat] || 0) + 1;
      });
    }
    
    // 统计标签
    if (frontMatter.tags) {
      const tags = Array.isArray(frontMatter.tags) 
        ? frontMatter.tags 
        : [frontMatter.tags];
      tags.forEach(tag => {
        const tagName = typeof tag === 'string' ? tag : tag.name;
        stats.tags[tagName] = (stats.tags[tagName] || 0) + 1;
      });
    }
    
    // 按年份统计
    if (frontMatter.date) {
      const date = new Date(frontMatter.date);
      const year = date.getFullYear();
      const month = `${year}-${String(date.getMonth() + 1).padStart(2, '0')}`;
      
      stats.postsByYear[year] = (stats.postsByYear[year] || 0) + 1;
      stats.postsByMonth[month] = (stats.postsByMonth[month] || 0) + 1;
    }
    
    // 收集文章信息
    const wordCount = body.split(/\s+/).length;
    posts.push({
      title: frontMatter.title || file,
      file: file,
      date: frontMatter.date,
      categories: frontMatter.categories || [],
      tags: frontMatter.tags || [],
      wordCount: wordCount,
      hasDescription: !!frontMatter.description
    });
  });
  
  // 排序文章
  posts.sort((a, b) => {
    const dateA = a.date ? new Date(a.date) : new Date(0);
    const dateB = b.date ? new Date(b.date) : new Date(0);
    return dateB - dateA;
  });
  
  // 最近发布的文章
  stats.recentPosts = posts.slice(0, 10).map(p => ({
    title: p.title,
    date: p.date,
    wordCount: p.wordCount
  }));
  
  // 最长和最短的文章
  const sortedByLength = [...posts].sort((a, b) => b.wordCount - a.wordCount);
  stats.longestPosts = sortedByLength.slice(0, 5).map(p => ({
    title: p.title,
    wordCount: p.wordCount
  }));
  stats.shortestPosts = sortedByLength.slice(-5).reverse().map(p => ({
    title: p.title,
    wordCount: p.wordCount
  }));
  
  // 计算平均字数
  const totalWords = posts.reduce((sum, p) => sum + p.wordCount, 0);
  stats.averageWordCount = Math.round(totalWords / posts.length);
  
  // 统计缺少描述的文章
  stats.postsWithoutDescription = posts.filter(p => !p.hasDescription).length;
  
  return { stats, posts };
}

function generateReport(data) {
  const { stats } = data;
  
  let report = `# 博客数据分析报告\n\n`;
  report += `生成时间: ${new Date().toLocaleString('zh-CN')}\n\n`;
  
  // 基本统计
  report += `## 基本统计\n\n`;
  report += `- 文章总数: ${stats.totalPosts}\n`;
  report += `- 平均字数: ${stats.averageWordCount} 字\n`;
  report += `- 缺少描述的文章: ${stats.postsWithoutDescription}\n\n`;
  
  // 分类统计
  report += `## 分类分布\n\n`;
  const sortedCategories = Object.entries(stats.categories)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 10);
  sortedCategories.forEach(([cat, count]) => {
    report += `- ${cat}: ${count} 篇\n`;
  });
  report += `\n`;
  
  // 标签统计
  report += `## 热门标签 (Top 20)\n\n`;
  const sortedTags = Object.entries(stats.tags)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 20);
  sortedTags.forEach(([tag, count]) => {
    report += `- ${tag}: ${count} 篇\n`;
  });
  report += `\n`;
  
  // 按年份统计
  report += `## 按年份统计\n\n`;
  const sortedYears = Object.keys(stats.postsByYear).sort().reverse();
  sortedYears.forEach(year => {
    report += `- ${year}年: ${stats.postsByYear[year]} 篇\n`;
  });
  report += `\n`;
  
  // 最近发布的文章
  report += `## 最近发布的文章 (Top 10)\n\n`;
  stats.recentPosts.forEach((post, index) => {
    report += `${index + 1}. ${post.title} (${post.wordCount} 字, ${post.date})\n`;
  });
  report += `\n`;
  
  // 最长文章
  report += `## 最长的文章 (Top 5)\n\n`;
  stats.longestPosts.forEach((post, index) => {
    report += `${index + 1}. ${post.title}: ${post.wordCount} 字\n`;
  });
  report += `\n`;
  
  return report;
}

// 运行分析
if (require.main === module) {
  try {
    console.log('开始分析博客数据...\n');
    const data = analyzeBlog();
    const report = generateReport(data);
    
    // 输出到控制台
    console.log(report);
    
    // 保存到文件
    const reportPath = path.join(process.cwd(), 'blog-analysis-report.md');
    fs.writeFileSync(reportPath, report, 'utf8');
    console.log(`\n报告已保存到: ${reportPath}`);
    
    // 同时保存 JSON 数据
    const jsonPath = path.join(process.cwd(), 'blog-analysis-data.json');
    fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2), 'utf8');
    console.log(`数据已保存到: ${jsonPath}`);
    
  } catch (error) {
    console.error('分析失败:', error);
    process.exit(1);
  }
}

module.exports = { analyzeBlog, generateReport };

// scripts/sync-from-notion.js
// 提示词：生成脚本，从 Notion 同步内容到 Hexo

const { Client } = require('@notionhq/client');
// Cursor 生成的 Notion 同步逻辑

// 在插件中添加调试日志
hexo.extend.filter.register('before_post_render', function(data) {
  console.log('Processing post:', data.title);
  // 你的代码逻辑
  return data;
});