const fs = require('fs');
const path = require('path');
const https = require('https');

// 加载环境变量
function loadEnv() {
    try {
        const dotenv = require('dotenv');

        // 尝试从多个位置加载.env文件
        const envPaths = [path.join(__dirname, '.env'), path.join(__dirname, '..', '.env')];

        for (const envPath of envPaths) {
            if (fs.existsSync(envPath)) {
                console.log(`📄 加载环境变量文件: ${envPath}`);
                dotenv.config({path: envPath});

                // 验证token是否加载成功
                if (process.env.BLOG_CNB_ISSUE_TOKEN && process.env.BLOG_CNB_ISSUE_TOKEN !== 'YOUR_TOKEN_HERE') {
                    console.log('✅ Token加载成功');
                    return true;
                } else {
                    console.log('⚠️  Token未在环境变量中找到');
                }
            }
        }

        console.log('⚠️  未找到.env文件，将直接使用环境变量');
        return false;
    } catch (e) {
        console.log('⚠️  dotenv加载失败:', e.message);
        console.log('💡 请运行: npm install dotenv');
        return false;
    }
}

loadEnv();


// 配置
const CONFIG = {
    token: process.env.BLOG_CNB_ISSUE_TOKEN || 'YOUR_TOKEN_HERE', // 从环境变量获取token
    baseUrl: process.env.BLOG_CNB_ISSUE_API_URL || 'https://api.cnb.cool/xqitw/blog/-/issues',
    postsDir: path.join(__dirname, 'source/_posts'),
    pageSize: 100,
    delay: 1000 // 1秒延迟
};

// HTTP请求封装
function httpsRequest(url) {
    return new Promise((resolve, reject) => {
        const options = {
            headers: {
                'Authorization': `Bearer ${CONFIG.token}`, 'Accept': 'application/json'
            }
        };

        https.get(url, options, (res) => {
            let data = '';
            res.on('data', (chunk) => data += chunk);
            res.on('end', () => {
                try {
                    resolve(JSON.parse(data));
                } catch (e) {
                    reject(e);
                }
            });
        }).on('error', reject);
    });
}

// 延迟函数
function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// 获取issue列表
async function getIssues(page = 1) {
    const url = `${CONFIG.baseUrl}?page=${page}&page_size=${CONFIG.pageSize}&order_by=-created_at`;
    console.log(`获取第 ${page} 页issue列表...`);

    try {
        const issues = await httpsRequest(url);
        await sleep(CONFIG.delay);
        return issues;
    } catch (error) {
        console.error(`获取第 ${page} 页失败:`, error.message);
        return [];
    }
}

// 获取issue详情
async function getIssueDetail(number) {
    const url = `${CONFIG.baseUrl}/${number}`;
    console.log(`获取issue #${number} 详情...`);

    try {
        const detail = await httpsRequest(url);
        await sleep(CONFIG.delay);
        return detail;
    } catch (error) {
        console.error(`获取issue #${number} 详情失败:`, error.message);
        return null;
    }
}

// 格式化日期为ISO格式
function formatDate(dateString) {
    return new Date(dateString).toISOString();
}

// 解析标签和分类
function parseLabels(labels) {
    if (!labels || !Array.isArray(labels)) {
        return {categories: [], tags: []};
    }

    const categories = [];
    const tags = [];

    labels.forEach(label => {
        const labelName = label.name;
        if (labelName.startsWith('分类:')) {
            // 移除"分类:"前缀，作为分类
            categories.push(labelName.substring(3).trim());
        } else {
            tags.push(labelName);
        }
    });

    return {categories, tags};
}

// 生成Hexo文章front matter
function generateFrontMatter(issue) {
    const {categories, tags} = parseLabels(issue.labels);

    let frontMatter = `---
title: ${issue.title}
date: ${formatDate(issue.created_at)}
updated: ${formatDate(issue.updated_at)}
author: ${issue.author ? issue.author.nickname : 'Unknown'}
author_username: ${issue.author ? issue.author.username : 'unknown'}
categories: [${categories.map(cat => `"${cat}"`).join(', ')}]
tags: [${tags.map(tag => `"${tag}"`).join(', ')}]
comment_count: ${issue.comment_count || 0}
issue_number: ${issue.number}
state: ${issue.state}
---
`;

    return frontMatter;
}

// 解析友情链接详情
function parseFriendLinkDetail(body) {
    if (!body) return [];

    const friendLinks = [];

    // 匹配所有代码块（支持 ```text 和 ``` 等格式）
    const codeBlockRegex = /```(?:text|)?\s*([\s\S]*?)```/g;
    let match;

    while ((match = codeBlockRegex.exec(body)) !== null) {
        const codeContent = match[1].trim();
        const result = {};

        // 使用正则匹配各个字段
        const nameMatch = codeContent.match(/站点名称[：:]\s*(.+)/);
        const urlMatch = codeContent.match(/站点地址[：:]\s*(.+)/);
        const descMatch = codeContent.match(/站点描述[：:]\s*(.+)/);
        const imageMatch = codeContent.match(/站点头像[：:]\s*(.+)/);

        if (nameMatch) result.name = nameMatch[1].trim();
        if (urlMatch) result.url = urlMatch[1].trim();
        if (descMatch) result.desc = descMatch[1].trim();
        if (imageMatch) result.image = imageMatch[1].trim();

        // 检查是否所有必要字段都存在
        if (result.name && result.url) {
            friendLinks.push(result);
        }
    }

    return friendLinks;
}

// 更新友情链接数据文件
async function updateFriendData(friendLinks) {
    const dataFilePath = path.join(__dirname, 'source', 'friend', '_data.yml');

    try {
        let yamlContent = '';
        let existingLinks = [];

        // 读取现有数据
        if (fs.existsSync(dataFilePath)) {
            yamlContent = await fs.promises.readFile(dataFilePath, 'utf8');
            // 解析现有链接
            existingLinks = parseYamlFriendLinks(yamlContent);
        }

        // 确保目录存在
        const friendDir = path.dirname(dataFilePath);
        if (!fs.existsSync(friendDir)) {
            fs.mkdirSync(friendDir, {recursive: true});
        }

        // 合并新链接和现有链接
        for (const friendLink of friendLinks) {
            const existingIndex = existingLinks.findIndex(item => item.name === friendLink.name);
            if (existingIndex !== -1) {
                existingLinks[existingIndex] = friendLink;
                console.log(`🔄 已更新友情链接: ${friendLink.name}`);
            } else {
                existingLinks.push(friendLink);
                console.log(`➕ 已添加友情链接: ${friendLink.name}`);
            }
        }

        // 生成新的YAML内容
        const newYamlContent = generateYamlFriendLinks(existingLinks);
        await fs.promises.writeFile(dataFilePath, newYamlContent, 'utf8');
        return true;
    } catch (error) {
        console.error(`❌ 更新友情链接数据失败:`, error.message);
        return false;
    }
}

// 解析YAML格式的友情链接
function parseYamlFriendLinks(yamlContent) {
    const links = [];
    const lines = yamlContent.split('');
    let currentLink = null;

    for (const line of lines) {
        const trimmedLine = line.trim();

        if (trimmedLine.startsWith('- name:')) {
            if (currentLink) {
                links.push(currentLink);
            }
            currentLink = {name: trimmedLine.replace('- name:', '').trim()};
        } else if (currentLink && trimmedLine.startsWith('url:')) {
            currentLink.url = trimmedLine.replace('url:', '').trim();
        } else if (currentLink && trimmedLine.startsWith('desc:')) {
            currentLink.desc = trimmedLine.replace('desc:', '').trim();
        } else if (currentLink && trimmedLine.startsWith('image:')) {
            currentLink.image = trimmedLine.replace('image:', '').trim();
        }
    }

    if (currentLink) {
        links.push(currentLink);
    }

    return links;
}

// 生成YAML格式的友情链接
function generateYamlFriendLinks(links) {
    if (links.length === 0) return '';

    return links.map(link => {
        let yaml = `\n- name: ${link.name}`;
        if (link.url) yaml += `
  url: ${link.url}`;
        if (link.desc) yaml += `
  desc: ${link.desc}`;
        if (link.image) yaml += `
  image: ${link.image}`;
        return yaml;
    }).join('') + '';
}

// 创建文章文件
async function createPostFile(issue) {
    let fileName, filePath;

    // 判断是否为关于页面
    if (issue.title.trim() === '关于') {
        fileName = 'index.md';
        const aboutDir = path.join(__dirname, 'source', 'about');

        // 确保about目录存在
        if (!fs.existsSync(aboutDir)) {
            fs.mkdirSync(aboutDir, {recursive: true});
            console.log(`📁 创建目录: ${aboutDir}`);
        }

        filePath = path.join(aboutDir, fileName);
        console.log(`📄 检测到关于页面，将生成到: about/${fileName}`);
    } else if (issue.title.trim() === '友情链接') {
        fileName = 'index.md';
        const friendDir = path.join(__dirname, 'source', 'friend');

        // 确保friend目录存在
        if (!fs.existsSync(friendDir)) {
            fs.mkdirSync(friendDir, {recursive: true});
            console.log(`📁 创建目录: ${friendDir}`);
        }

        filePath = path.join(friendDir, fileName);
        console.log(`📄 检测到友情链接页面，将生成到: friend/${fileName}`);
    } else if (issue.title.trim() === '友情链接详情') {
        // 处理友情链接详情，解析并更新_data.yml
        const friendLinks = parseFriendLinkDetail(issue.body);
        if (friendLinks && friendLinks.length > 0) {
            await updateFriendData(friendLinks);
            console.log(`✅ 已处理 ${friendLinks.length} 个友情链接`);
            return true;
        } else {
            console.log(`⚠️  无法解析友情链接详情: ${issue.number}`);
            return false;
        }
    } else {
        fileName = `post-${issue.number}.md`;
        filePath = path.join(CONFIG.postsDir, fileName);
    }

    const content = generateFrontMatter(issue) + (issue.body || '');

    try {
        await fs.promises.writeFile(filePath, content, 'utf8');
        console.log(`✅ 已创建文件: ${fileName}`);
        return true;
    } catch (error) {
        console.error(`❌ 创建文件失败 ${fileName}:`, error.message);
        return false;
    }
}

// 检查文件是否已存在
function fileExists(fileName) {
    let filePath;
    if (fileName === 'about/index.md') {
        filePath = path.join(__dirname, 'source', 'about', 'index.md');
    } else if (fileName === 'friend/index.md') {
        filePath = path.join(__dirname, 'source', 'friend', 'index.md');
    } else {
        filePath = path.join(CONFIG.postsDir, fileName);
    }
    return fs.existsSync(filePath);
}

// 主函数
async function main() {
    console.log('🚀 开始获取issues并生成Hexo文章...');

    // 检查token
    if (CONFIG.token === 'YOUR_TOKEN_HERE') {
        console.error('❌ 请设置环境变量 BLOG_CNB_ISSUE_TOKEN 或修改CONFIG.token');
        process.exit(1);
    }

    // 确保posts目录存在
    if (!fs.existsSync(CONFIG.postsDir)) {
        fs.mkdirSync(CONFIG.postsDir, {recursive: true});
        console.log(`📁 创建目录: ${CONFIG.postsDir}`);
    }

    console.log(`🔗 API地址: ${CONFIG.baseUrl}`);
    console.log(`📁 文章保存目录: ${CONFIG.postsDir}`);
    console.log(`🏷️  分类规则: 以"分类:"开头的标签将作为分类（自动移除前缀）`);

    let page = 1;
    let totalProcessed = 0;
    let totalSkipped = 0;
    let totalErrors = 0;

    try {
        while (true) {
            // 获取当前页的issues
            const issues = await getIssues(page);

            if (!issues || issues.length === 0) {
                console.log('✅ 没有更多issues，处理完成');
                break;
            }

            console.log(`📄 第 ${page} 页找到 ${issues.length} 个issues`);

            // 处理每个issue
            for (const issue of issues) {
                try {
                    // 检查文件是否已存在
                    let fileName;
                    if (issue.title.trim() === '关于') {
                        fileName = 'about/index.md';
                    } else if (issue.title.trim() === '友情链接') {
                        fileName = 'friend/index.md';
                    } else if (issue.title.trim() === '友情链接详情') {
                        // 友情链接详情不需要检查文件存在性，直接处理
                        fileName = null;
                    } else {
                        fileName = `post-${issue.number}.md`;
                    }

                    if (fileName && fileExists(fileName)) {
                        console.log(`🔄 覆盖已存在的文件: ${fileName}`);
                    }

                    // 获取详情
                    const detail = await getIssueDetail(issue.number);
                    if (!detail) {
                        totalErrors++;
                        continue;
                    }

                    // 创建文章文件
                    const success = await createPostFile(detail);
                    if (success) {
                        totalProcessed++;
                    } else {
                        totalErrors++;
                    }

                } catch (error) {
                    console.error(`处理issue #${issue.number} 时出错:`, error.message);
                    totalErrors++;
                }
            }

            page++;
        }

        console.log('\n📊 处理完成统计:');
        console.log(`✅ 成功处理: ${totalProcessed} 篇文章`);
        console.log(`⏭️  跳过已存在: ${totalSkipped} 篇文章`);
        console.log(`❌ 处理失败: ${totalErrors} 篇文章`);
        console.log(`📁 文章保存在: ${CONFIG.postsDir}`);

    } catch (error) {
        console.error('❌ 主程序执行出错:', error.message);
        process.exit(1);
    }
}

// 如果直接运行此脚本
if (require.main === module) {
    main();
}

module.exports = {
    main, getIssues, getIssueDetail, createPostFile, parseLabels
};