Wechat 10w Hot

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
公众号10w+热门文章榜单获取脚本

功能：
1. 调用API获取10w+阅读热门文章数据（按分类和时间查询）
2. 按互动数排序
3. 输出TOP榜单列表（纯文本格式）
4. 提供四维度内容分析（内容概述、热点利用、传播作用、达成效果）

使用方法：
python fetch_hot_articles.py --type "科技数码" --start_date "2024-01-01" --end_date "2024-01-02"
python fetch_hot_articles.py --type "总排名" --start_date "yesterday" --end_date ""
python fetch_hot_articles.py --type "" --start_date "daybeforeyesterday" --end_date ""
"""

import argparse
import json
import os
import sys
from datetime import datetime, timedelta
from urllib.request import Request, urlopen
from urllib.error import URLError, HTTPError


# 标准分类列表
STANDARD_CATEGORIES = [
    "人文资讯", "知识百科", "健康养生", "时尚潮流", "美食餐饮", "乐活生活",
    "旅游出行", "搞笑幽默", "情感心理", "体育娱乐", "美容美体", "文摘精选",
    "民生资讯", "财富理财", "科技数码", "创投商业", "汽车交通", "房产楼市",
    "职场发展", "教育考试", "学术研究", "企业品牌", "总排名"
]


def parse_date(date_str: str) -> str:
    """
    解析日期参数

    Args:
        date_str: 日期字符串，支持：
                 - "yesterday": 昨天
                 - "daybeforeyesterday": 前天
                 - "today": 今天
                 - "": 不限时间
                 - "YYYY-MM-DD": 具体日期

    Returns:
        格式化的日期字符串（YYYY-MM-DD），如果为空则返回空字符串
    """
    if not date_str or date_str == "":
        return ""

    if date_str == "yesterday":
        # 昨天
        yesterday = datetime.now() - timedelta(days=1)
        return yesterday.strftime("%Y-%m-%d")

    if date_str == "daybeforeyesterday":
        # 前天
        day_before_yesterday = datetime.now() - timedelta(days=2)
        return day_before_yesterday.strftime("%Y-%m-%d")

    if date_str == "today":
        # 今天
        return datetime.now().strftime("%Y-%m-%d")

    # 尝试解析具体日期格式
    try:
        # 支持 YYYY-MM-DD 格式
        dt = datetime.strptime(date_str, "%Y-%m-%d")
        return dt.strftime("%Y-%m-%d")
    except ValueError:
        pass

    # 默认返回空
    return ""


def parse_count_to_int(count_str: str) -> int:
    """
    将阅读数字符串转换为整数

    Args:
        count_str: 阅读数字符串，如 "10w+", "5w+", "1.5w+", "9w+", "1000"

    Returns:
        整数形式的阅读数
    """
    if not count_str:
        return 0

    try:
        count_str = str(count_str).strip()

        # 处理 "10w+" 格式
        if "w+" in count_str.lower():
            # 提取数字部分，如 "10w+" -> "10"
            num_str = count_str.lower().replace("w+", "").replace("w", "")
            # 处理小数，如 "1.5w+" -> 1.5
            if "." in num_str:
                num = float(num_str)
                return int(num * 10000)
            else:
                num = float(num_str)
                return int(num * 10000)

        # 处理 "w" 格式（没有加号）
        if "w" in count_str.lower():
            num_str = count_str.lower().replace("w", "")
            if "." in num_str:
                num = float(num_str)
                return int(num * 10000)
            else:
                num = float(num_str)
                return int(num * 10000)

        # 处理纯数字
        return int(float(count_str))
    except:
        return 0


def analyze_content(title: str, summary: str) -> str:
    """
    四维度分析文章内容

    Args:
        title: 文章标题
        summary: 文章摘要

    Returns:
        四维度分析文本（内容概述、热点利用、传播作用、达成效果）
    """
    content = f"{title} {summary}".lower()

    # 1. 内容概述
    overview_keywords = {
        "政策": "解读政策新规", "新规": "解读政策新规", "实施": "解读政策新规",
        "调整": "分析调整内容", "变化": "分析变化趋势", "趋势": "分析趋势走向",
        "技术": "介绍技术发展", "科技": "介绍科技进展", "创新": "介绍创新成果",
        "市场": "分析市场动态", "投资": "分析投资机会", "理财": "提供理财建议",
        "健康": "科普健康知识", "养生": "分享养生方法", "疾病": "介绍疾病防治",
        "教育": "探讨教育问题", "考试": "分析考试动态", "学习": "提供学习方法",
    }
    overview = "分析文章核心内容"
    for keyword, desc in overview_keywords.items():
        if keyword in content:
            overview = desc
            break

    # 2. 热点利用
    hotspot_keywords = {
        "政策": "政策热点", "新规": "政策热点", "改革": "政策热点",
        "AI": "人工智能热点", "人工智能": "人工智能热点", "ChatGPT": "人工智能热点",
        "新能源": "新能源热点", "电动车": "新能源热点", "特斯拉": "新能源热点",
        "房价": "楼市热点", "房产": "楼市热点", "房贷": "楼市热点",
        "降息": "金融热点", "加息": "金融热点", "利率": "金融热点",
        "疫情": "公共卫生热点", "流感": "公共卫生热点", "病毒": "公共卫生热点",
        "国产": "国产替代热点", "自主": "自主可控热点", "突破": "技术突破热点",
        "财富": "财富热点", "赚钱": "财富热点", "投资": "投资热点",
    }
    hotspot = "结合时事热点"
    for keyword, desc in hotspot_keywords.items():
        if keyword.lower() in content:
            hotspot = f"借用{desc}"
            break

    # 3. 传播作用
    spread_keywords = {
        "政策": "提供政策解读", "新规": "提供新规解读", "解读": "提供权威解读",
        "分析": "提供专业分析", "深度": "提供深度分析", "专业": "提供专业见解",
        "实用": "提供实用价值", "方法": "提供方法论", "技巧": "提供实用技巧",
        "揭秘": "满足好奇心", "曝光": "满足知情权", "内幕": "满足求知欲",
        "观点": "引发思考讨论", "争议": "引发话题讨论", "话题": "引发话题关注",
    }
    spread = "提供信息价值"
    for keyword, desc in spread_keywords.items():
        if keyword in content:
            spread = desc
            break

    # 4. 达成效果
    effect_keywords = {
        "政策": "提升政策认知", "新规": "普及新规知识", "实施": "推动政策落地",
        "分析": "增强认知水平", "深度": "深化理解层次", "专业": "建立专业认知",
        "实用": "提供实践指导", "方法": "指导实际操作", "技巧": "提升实操能力",
        "投资": "辅助决策判断", "理财": "提供理财参考", "赚钱": "启发创富思路",
        "健康": "提升健康意识", "养生": "推广养生理念", "疾病": "增强防范意识",
    }
    effect = "促进信息传播"
    for keyword, desc in effect_keywords.items():
        if keyword in content:
            effect = desc
            break

    # 组合输出
    return f"{overview}，{hotspot}，{spread}，{effect}"


def _get_api_key():
    """从当前环境变量获取 REDFOX_API_KEY"""
    key = os.environ.get("REDFOX_API_KEY")
    if not key:
        print("❌ 未找到 REDFOX_API_KEY，请配置环境变量：export REDFOX_API_KEY=<your_api_key>", file=sys.stderr)
        sys.exit(1)
    return key


def fetch_articles_by_category(category: str, start_date: str, end_date: str, source: str = "公众号10w+阅读文章推荐-GitHub") -> list:
    """
    根据分类和时间获取文章数据
    使用 urllib.request 发送 HTTPS 请求

    Args:
        category: 分类名称（如：科技数码、健康养生、总排名等）
        start_date: 开始日期（YYYY-MM-DD格式）
        end_date: 结束日期（YYYY-MM-DD格式）
        source: 数据来源

    Returns:
        文章列表
    """
    # API配置
    api_url = "https://redfox.hk/story/api/cozeSkill/getWxDataByCategoryAndTime"

    # 获取 API Key
    api_key = _get_api_key()

    # 构建请求参数
    params = {
        "type": category if category else "总排名",
        "source": source,
        "startDate": start_date,
        "endDate": end_date
    }

    # 构建请求体（JSON格式）
    post_data = json.dumps(params, ensure_ascii=False).encode("utf-8")

    try:
        # 构建请求头
        headers = {
            "Content-Type": "application/json",
            "X-API-KEY": api_key,
        }

        # 构建POST请求
        req = Request(api_url, data=post_data, headers=headers, method="POST")

        # 打印调试信息
        print(f"\n🔍 调试信息：")
        print(f"   URL: {api_url}")
        print(f"   Method: POST")
        print(f"   X-API-KEY: {api_key[:8]}...（已隐藏）")
        print(f"   参数: type={params['type']}, source={source}, startDate={start_date}, endDate={end_date}")
        print(f"   请求体: {post_data.decode('utf-8')}")

        # 发送请求
        with urlopen(req, timeout=30) as response:
            body = response.read().decode("utf-8")

        # 解析JSON数据
        data = json.loads(body)

        # 检查响应数据
        if data is None:
            print(f"❌ 响应数据为空")
            return []

        # 检查业务状态码（兼容 200 和 2000）
        code = data.get("code") if isinstance(data, dict) else None
        if code and code not in (200, 2000):
            msg = data.get("msg") or data.get("message") or "未知错误"
            print(f"⚠️ API返回错误: code={code}, msg={msg}")
            return []

        # 从 tenWReadingRank 字段获取文章列表
        if isinstance(data, dict) and "data" in data and data["data"] is not None and "tenWReadingRank" in data["data"]:
            articles = data["data"]["tenWReadingRank"]
            return articles if articles else []
        else:
            # API返回错误信息
            if isinstance(data, dict) and "msg" in data:
                print(f"⚠️ API返回: {data['msg']}")
            return []

    except HTTPError as e:
        print(f"❌ HTTP错误: {e.code} {e.reason}")
        return []
    except URLError as e:
        print(f"❌ URL错误: {e.reason}")
        return []
    except json.JSONDecodeError as e:
        print(f"❌ JSON解析失败: {e}")
        return []
    except Exception as e:
        print(f"❌ 数据处理失败: {e}")
        return []


def process_ranking_data(articles: list) -> list:
    """
    处理和排序文章数据

    Args:
        articles: 原始文章列表

    Returns:
        排序后的文章列表
    """
    if not articles:
        return []

    # 按互动数排序（降序）
    sorted_articles = sorted(
        articles,
        key=lambda x: parse_count_to_int(x.get("interactiveCount", "0")),
        reverse=True
    )

    return sorted_articles


def format_summary_table(articles: list) -> str:
    """
    格式化文章概览表格

    Args:
        articles: 文章列表

    Returns:
        Markdown表格文本
    """
    if not articles:
        return "暂无数据"

    lines = []
    lines.append("| 序号 | 标题 | 作者 | 阅读数 |")
    lines.append("|------|------|------|--------|")

    for i, article in enumerate(articles, 1):
        title = article.get("title", "未知标题")
        author = article.get("userName", "未知作者")
        read_count = article.get("clicksCount", "0")

        # 标题过长时截断
        if len(title) > 30:
            title = title[:30] + "..."

        lines.append(f"| {i} | {title} | {author} | {read_count} |")

    return "\n".join(lines)


def format_ranking_list(articles: list, limit: int = None) -> str:
    """
    格式化输出文章列表（详细版）

    Args:
        articles: 文章列表
        limit: 限制输出数量

    Returns:
        格式化的文本
    """
    if not articles:
        return "未获取到符合条件的爆款内容数据"

    display_articles = articles[:limit] if limit else articles

    lines = []
    for i, article in enumerate(display_articles, 1):
        title = article.get("title", "未知标题")
        ori_url = article.get("oriUrl", "")
        author = article.get("userName", "未知作者")
        account_id = article.get("accountId", "")
        read_count = article.get("clicksCount", "0")
        publish_time = article.get("publicTime", "未知时间")
        summary = article.get("summary", "")

        # 内容分析
        content_analysis = analyze_content(title, summary)

        # 格式化输出
        lines.append(f"**{i}、[{title}]({ori_url})**")
        lines.append(f"📄 作者：[{author}](https://mp.weixin.qq.com/mp/profileExt?action=home&__biz={account_id}#wechat_redirect)")
        lines.append(f"👀 阅读数：{read_count}")
        lines.append(f"⏰ 发布时间：{publish_time}")
        lines.append(f"🔍 内容分析：{content_analysis}")
        lines.append("---")
        lines.append("")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="获取公众号10w+热门文章榜单")

    parser.add_argument("--type", type=str, default="总排名",
                        help="分类名称（如：科技数码、健康养生、总排名等），默认：总排名")
    parser.add_argument("--start_date", type=str, required=True,
                        help="开始日期（必传，支持：yesterday、daybeforeyesterday、YYYY-MM-DD）")
    parser.add_argument("--end_date", type=str, required=True,
                        help="结束日期（必传，支持：yesterday、daybeforeyesterday、YYYY-MM-DD）")
    parser.add_argument("--mode", type=str, default="preview",
                        help="输出模式：preview（预览前10条）或 full（全部展示）")
    parser.add_argument("--limit", type=int, default=10,
                        help="预览模式下展示的数量，默认10")
    parser.add_argument("--source", type=str, default="公众号10w+阅读文章推荐-GitHub",
                        help="数据来源")
    parser.add_argument("--temp_file", type=str, default="temp_articles.json",
                        help="临时数据文件名")

    args = parser.parse_args()

    # 确定分类
    category = args.type if args.type else "总排名"

    # 解析日期
    start_date = parse_date(args.start_date)
    end_date = parse_date(args.end_date)

    # 输出数据说明
    print("\n💡 数据说明")
    print("最新10w+阅读爆文推荐将在每日19点30分准时更新，以下数据为获取时间时的快照，和实时数据有所差别。")
    print("-" * 60)

    # 获取数据
    print(f"\n🔍 正在获取【{category}】分类的文章数据...")
    if start_date:
        print(f"📅 时间范围：{start_date}" + (f" 至 {end_date}" if end_date else ""))

    articles = fetch_articles_by_category(category, start_date, end_date, args.source)

    if not articles:
        print("\n📊 文章概览\n")
        print("暂无数据")
        print("\n📝 文章详情\n")
        print("未获取到符合条件的爆款内容数据")
        print("\n============================================================")
        print("\n共获取到 0 条10w+热门文章数据")
        print("💡 建议：尝试调整分类关键词或时间范围")
        return

    # 处理和排序数据
    sorted_articles = process_ranking_data(articles)
    total_count = len(sorted_articles)

    # 保存数据到临时JSON文件
    temp_file = args.temp_file if args.temp_file else "temp_articles.json"
    with open(temp_file, 'w', encoding='utf-8') as f:
        json.dump({
            "category": category,
            "articles": sorted_articles,
            "total_count": total_count
        }, f, ensure_ascii=False, indent=2)

    print(f"✅ 数据已保存到临时文件：{temp_file}")

    # 根据模式输出
    if args.mode == "preview":
        # 预览模式：展示前N条
        preview_count = min(args.limit, total_count)
        preview_articles = sorted_articles[:preview_count]

        # 输出文章概览表格
        print("\n📊 文章概览\n")
        print(format_summary_table(preview_articles))

        # 输出文章详情
        print("\n📝 文章详情\n")
        print(format_ranking_list(preview_articles))

        # 统计信息
        print("\n============================================================")
        print(f"\n共获取到 {total_count} 条10w+热门文章数据，当前展示前 {preview_count} 条")

        # 如果还有更多数据，提示用户
        if total_count > preview_count:
            remaining = total_count - preview_count
            print(f"💡 提示：还有 {remaining} 条数据未展示，是否需要全部展示？")

        # 文章数量较少提示（少于10篇）
        if total_count < 10:
            category_name = args.type if args.type != "总排名" else "综合"
            print(f"\n💡 {category_name}赛道10w+文章较少，您可以拓展过去30天或者看看综合10w+文章~")

    else:
        # 完整模式：展示全部
        # 输出文章概览表格
        print("\n📊 文章概览\n")
        print(format_summary_table(sorted_articles))

        # 输出文章详情
        print("\n📝 文章详情\n")
        print(format_ranking_list(sorted_articles))

        # 统计信息
        print("\n============================================================")
        print(f"\n共获取到 {total_count} 条10w+热门文章数据（已全部展示）")

        # 文章数量较少提示（少于10篇）
        if total_count < 10:
            category_name = args.type if args.type != "总排名" else "综合"
            print(f"\n💡 {category_name}赛道10w+文章较少，您可以拓展过去30天或者看看综合10w+文章~")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
公众号10w+热门文章HTML生成脚本

功能：
1. 读取API数据
2. 生成公众号风格的HTML页面
3. 支持PDF导出

使用方法：
python generate_hot_html.py --data_file data.json --output ranking.html
python generate_hot_html.py --articles '[{"title": "...", ...}]' --output ranking.html
"""

import argparse
import json
import os
from datetime import datetime


def get_rank_display(rank: int) -> str:
    """获取排名显示（奖牌或数字）"""
    if rank == 1:
        return "🥇"
    elif rank == 2:
        return "🥈"
    elif rank == 3:
        return "🥉"
    else:
        return str(rank)


def get_article_html(article: dict, rank: int, is_top: bool = False) -> str:
    """生成单篇文章的HTML"""
    try:
        title = article.get("title", "未知标题")
        url = article.get("oriUrl", "#")
        account = article.get("userName", article.get("accountId", "未知账号"))
        account_id = article.get("accountId", "")
        reads = article.get("clicksCount", "0")
        
        # 处理日期
        public_time = article.get("publicTime", "")
        if public_time:
            try:
                date = str(public_time)[:10]
            except:
                date = ""
        else:
            date = ""

        # 生成公众号名片链接
        if account_id:
            account_url = f"https://open.weixin.qq.com/qr/code?username={account_id}"
        else:
            account_url = "#"

        top_class = " top-item" if is_top else ""
        rank_display = get_rank_display(rank)
        top_rank_class = " top" if is_top else ""

        return f'''
                    <li class="article-item{top_class}">
                        <div class="article-body">
                            <div class="article-rank{top_rank_class}">{rank_display}</div>
                            <div class="article-content">
                                <a href="{url}" target="_blank" class="article-title">{title}</a>
                                <div class="article-info">
                                    <span class="info-item"><a href="{account_url}" target="_blank" class="info-source-link"><span class="info-source-icon">👤</span>{account}</a></span>
                                    <span class="info-item"><span class="info-stat">📖 阅读 <span class="info-stat-value">{reads}</span></span></span>
                                    <span class="info-item"><span class="info-stat">📅 {date}</span></span>
                                </div>
                            </div>
                        </div>
                    </li>'''
    except:
        # 如果生成失败，返回空字符串
        return ""


def generate_html(keyword: str, articles: list, insights: dict = None, top_n: int = 10) -> str:
    """生成完整的HTML页面"""
    # 数据验证
    if not articles:
        articles = []
    
    # 计算统计数据
    try:
        account_count = len(set(a.get("accountId", "") for a in articles if a.get("accountId")))
    except:
        account_count = 0

    # 计算日期范围
    dates = []
    for a in articles:
        try:
            public_time = a.get("publicTime", "")
            if public_time:
                date_str = str(public_time)[:10]  # 只取日期部分
                if date_str and len(date_str) >= 10:  # 确保日期格式正确
                    dates.append(date_str)
        except:
            continue
    
    if dates:
        try:
            min_date = min(datetime.strptime(d, "%Y-%m-%d") for d in dates if d)
            max_date = max(datetime.strptime(d, "%Y-%m-%d") for d in dates if d)
            days = (max_date - min_date).days + 1
        except:
            days = 30
    else:
        days = 30

    # 生成文章列表HTML
    articles_html = ""
    for i, article in enumerate(articles[:top_n], 1):
        try:
            articles_html += get_article_html(article, i, i <= 3)
        except:
            # 如果单篇文章生成失败，跳过
            continue

    # 完整的HTML模板
    html = f'''<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{keyword} · 公众号10w+阅读文章</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/html2pdf.js/0.10.1/html2pdf.bundle.min.js"></script>
    <style>
        * {{
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }}

        body {{
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
            background: #f5f5f5;
            color: #333;
            line-height: 1.8;
            padding: 12px;
        }}

        .container {{
            max-width: 680px;
            margin: 0 auto;
            background: #fff;
            border-radius: 12px;
            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.06);
            overflow: hidden;
        }}

        .brand-header {{
            background: linear-gradient(135deg, #fff 0%, #f8fff8 100%);
            padding: 32px 24px 28px;
            text-align: center;
            border-bottom: 1px solid #eee;
        }}

        .brand-title {{
            font-size: 26px;
            font-weight: 700;
            color: #1a1a1a;
            margin-bottom: 8px;
            letter-spacing: 1px;
        }}

        .brand-subtitle {{
            font-size: 14px;
            color: #888;
        }}

        .export-btn {{
            display: inline-flex;
            align-items: center;
            gap: 4px;
            background: linear-gradient(135deg, #0088ff, #0066cc);
            color: #fff;
            border: none;
            padding: 5px 12px;
            border-radius: 12px;
            font-size: 12px;
            font-weight: 500;
            cursor: pointer;
            transition: all 0.3s ease;
            box-shadow: 0 2px 8px rgba(0, 136, 255, 0.3);
        }}

        .export-btn:hover {{
            transform: translateY(-1px);
            box-shadow: 0 4px 12px rgba(0, 136, 255, 0.4);
        }}

        .brand-stats {{
            display: flex;
            justify-content: center;
            gap: 32px;
            margin-top: 24px;
            padding-top: 20px;
            border-top: 1px dashed #e5e5e5;
        }}

        .brand-stat {{
            text-align: center;
        }}

        .brand-stat-num {{
            font-size: 24px;
            font-weight: 700;
            color: rgb(0, 179, 84);
        }}

        .brand-stat-label {{
            font-size: 12px;
            color: #999;
            margin-top: 4px;
        }}

        .content {{
            padding: 24px 20px;
        }}

        .section-header {{
            display: flex;
            align-items: center;
            justify-content: space-between;
            margin-bottom: 20px;
            gap: 12px;
        }}

        .section-header .export-btn {{
            font-size: 12px;
            padding: 5px 12px;
        }}

        .section-right {{
            display: flex;
            align-items: center;
            gap: 10px;
        }}

        .section-title {{
            font-size: 18px;
            font-weight: 600;
            color: #1a1a1a;
            display: flex;
            align-items: center;
            gap: 8px;
        }}

        .section-title::before {{
            content: "";
            width: 4px;
            height: 20px;
            background: rgb(0, 179, 84);
            border-radius: 2px;
        }}

        .section-badge {{
            background: rgba(0, 179, 84, 0.1);
            color: rgb(0, 179, 84);
            font-size: 12px;
            padding: 4px 12px;
            border-radius: 12px;
            font-weight: 500;
        }}

        .article-list {{
            list-style: none;
        }}

        .article-item {{
            background: #fff;
            border: 1px solid #eee;
            border-radius: 12px;
            padding: 20px;
            margin-bottom: 16px;
            transition: all 0.3s ease;
            position: relative;
            overflow: hidden;
        }}

        .article-item:hover {{
            border-color: rgb(0, 179, 84);
            box-shadow: 0 4px 16px rgba(0, 179, 84, 0.12);
            transform: translateY(-2px);
        }}

        .article-item:last-child {{
            margin-bottom: 0;
        }}

        .article-item.top-item {{
            background: linear-gradient(135deg, #fff 0%, #f8fff8 100%);
            border-color: rgba(0, 179, 84, 0.3);
        }}

        .article-item.top-item::before {{
            content: "";
            position: absolute;
            top: 0;
            left: 0;
            width: 4px;
            height: 100%;
            background: linear-gradient(180deg, rgb(0, 179, 84), #06a54a);
        }}

        .article-body {{
            display: flex;
            align-items: flex-start;
            gap: 14px;
        }}

        .article-rank {{
            width: 36px;
            height: 36px;
            background: rgb(0, 179, 84);
            color: #fff;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            font-weight: 700;
            font-size: 14px;
            flex-shrink: 0;
        }}

        .article-rank.top {{
            background: linear-gradient(135deg, #ffd700, #ff8c00);
            color: #fff;
            font-size: 22px;
            font-weight: normal;
        }}

        .article-content {{
            flex: 1;
        }}

        .article-title {{
            font-size: 17px;
            font-weight: 600;
            color: #1a1a1a;
            line-height: 1.5;
            text-decoration: none;
            display: block;
            margin-bottom: 12px;
            cursor: pointer;
            transition: color 0.2s;
        }}

        .article-title:hover {{
            color: rgb(0, 179, 84);
        }}

        .article-info {{
            display: flex;
            align-items: center;
            flex-wrap: wrap;
            gap: 0;
            font-size: 14px;
            color: #888;
        }}

        .info-item {{
            padding: 0 12px;
            position: relative;
        }}

        .info-item::before {{
            content: "|";
            position: absolute;
            left: 0;
            top: 50%;
            transform: translateY(-50%);
            color: #e0e0e0;
            font-size: 10px;
        }}

        .info-item:first-child {{
            padding-left: 0;
        }}

        .info-item:first-child::before {{
            display: none;
        }}

        .info-source-link {{
            display: inline-flex;
            align-items: center;
            gap: 4px;
            color: #0088ff;
            text-decoration: none;
            transition: color 0.2s;
        }}

        .info-source-link:hover {{
            text-decoration: underline;
        }}

        .info-source-icon {{
            display: inline-flex;
            align-items: center;
            justify-content: center;
            font-size: 14px;
            vertical-align: middle;
        }}

        .info-category {{
            font-size: 11px;
            color: rgb(0, 179, 84);
            background: rgba(0, 179, 84, 0.1);
            padding: 2px 8px;
            border-radius: 4px;
            font-weight: 500;
        }}

        .info-stat {{
            display: flex;
            align-items: center;
            gap: 4px;
        }}

        .info-stat-value {{
            color: #0088ff;
            font-weight: 600;
        }}

        .footer {{
            background: #fafafa;
            padding: 24px;
            text-align: center;
            border-top: 1px solid #eee;
        }}

        .footer-text {{
            font-size: 13px;
            color: #888;
        }}

        .footer-copy {{
            font-size: 11px;
            color: #bbb;
            margin-top: 8px;
        }}

        @media (max-width: 480px) {{
            body {{
                padding: 0;
            }}

            .container {{
                border-radius: 0;
            }}

            .brand-stats {{
                gap: 20px;
            }}

            .article-info {{
                gap: 8px;
            }}
        }}

        @media print {{
            .export-btn {{
                display: none !important;
            }}
            .container {{
                padding: 15mm !important;
            }}
            .brand-header {{
                padding: 8mm 10mm !important;
                margin-bottom: 8mm !important;
            }}
            .brand-stats {{
                padding: 6mm !important;
                gap: 10px !important;
            }}
            .brand-stat {{
                padding: 4mm 6mm !important;
            }}
            .section-header {{
                padding: 6mm 0 !important;
            }}
            .article-item {{
                padding: 6mm 8mm !important;
                margin-bottom: 4mm !important;
            }}
            .footer {{
                padding: 8mm !important;
            }}
        }}
    </style>
</head>
<body>
    <div class="container">
        <div class="brand-header">
            <h1 class="brand-title">{keyword} · 10w+阅读文章</h1>
            <p class="brand-subtitle">每日推送公众号10w+爆款内容，解析流量密码</p>
            <div class="brand-stats">
                <div class="brand-stat">
                    <div class="brand-stat-num">{top_n}</div>
                    <div class="brand-stat-label">篇爆款文章</div>
                </div>
                <div class="brand-stat">
                    <div class="brand-stat-num">{account_count}</div>
                    <div class="brand-stat-label">个账号</div>
                </div>
                <div class="brand-stat">
                    <div class="brand-stat-num">{days}</div>
                    <div class="brand-stat-label">天内热文</div>
                </div>
            </div>
        </div>

        <div class="content">
            <div class="section-header">
                <h2 class="section-title">TOP{top_n} 爆款文章</h2>
                <div class="section-right">
                    <span class="section-badge">阅读量排序</span>
                    <button class="export-btn" onclick="exportToPDF()">📥 导出PDF</button>
                </div>
            </div>

            <ul class="article-list">
                {articles_html}
            </ul>
        </div>

        <div class="footer">
            <p class="footer-text">公众号10w+阅读文章，每日更新最新爆文内容</p>
            <p class="footer-copy">备注：互动数据为入库快照，实时数据可能持续增长</p>
        </div>
    </div>

    <script>
        function exportToPDF() {{
            const element = document.querySelector('.container');
            const button = document.querySelector('.export-btn');
            button.style.display = 'none';

            // 计算内容高度，决定PDF尺寸
            const contentHeight = element.scrollHeight;
            const contentWidth = element.scrollWidth;
            // 根据内容比例决定纸张尺寸，mm为单位，1mm ≈ 3.78px
            const pdfWidth = Math.max(210, Math.ceil(contentWidth / 3.78) + 20);
            const pdfHeight = Math.max(297, Math.ceil(contentHeight / 3.78) + 20);

            const opt = {{
                margin: 0,
                filename: '{keyword}_爆款内容分析.pdf',
                image: {{ type: 'jpeg', quality: 0.95 }},
                html2canvas: {{
                    scale: 2,
                    useCORS: true,
                    logging: false,
                    scrollX: 0,
                    scrollY: 0
                }},
                jsPDF: {{
                    unit: 'mm',
                    format: [pdfWidth, pdfHeight],
                    orientation: pdfWidth > pdfHeight ? 'landscape' : 'portrait'
                }},
                pagebreak: {{ mode: 'none' }}
            }};

            html2pdf().set(opt).from(element).save().then(() => {{
                button.style.display = 'inline-flex';
            }});
        }}
    </script>
</body>
</html>'''

    return html


def main():
    parser = argparse.ArgumentParser(description="生成公众号10w+热门文章HTML")
    parser.add_argument("--temp_file", default="temp_articles.json", help="临时JSON文件路径")
    parser.add_argument("--output", default="ranking.html", help="输出文件路径")
    parser.add_argument("--display_count", type=int, default=None, help="要展示的文章数量（如果不指定，则展示所有文章）")

    args = parser.parse_args()

    try:
        # 从临时JSON文件读取数据
        try:
            with open(args.temp_file, "r", encoding="utf-8") as f:
                temp_data = json.load(f)
            keyword = temp_data.get("keyword", "热门文章")
            articles = temp_data.get("articles", [])
            if not isinstance(articles, list):
                articles = []
        except FileNotFoundError:
            print(f"错误: 临时文件不存在 - {args.temp_file}", file=sys.stderr)
            return 1
        except json.JSONDecodeError:
            print(f"错误: 临时文件格式错误 - {args.temp_file}", file=sys.stderr)
            return 1
        except Exception as e:
            print(f"错误: 读取临时文件失败 - {str(e)}", file=sys.stderr)
            return 1

        if not articles:
            print(f"错误: 临时文件中没有文章数据", file=sys.stderr)
            return 1

        # 根据display_count参数确定要展示的文章数量
        display_count = args.display_count if args.display_count is not None else len(articles)
        display_articles = articles[:display_count]

        print(f"✅ 从临时文件读取到 {len(articles)} 条文章数据，本次展示 {len(display_articles)} 条")

        # 生成HTML（使用display_articles而不是articles）
        try:
            html_content = generate_html(keyword, display_articles, None, len(display_articles))
        except Exception as e:
            print(f"错误: 生成HTML失败 - {str(e)}", file=sys.stderr)
            return 1

        # 写入文件
        try:
            with open(args.output, "w", encoding="utf-8") as f:
                f.write(html_content)
        except Exception as e:
            print(f"错误: 写入文件失败 - {str(e)}", file=sys.stderr)
            return 1

        print(f"✅ HTML文件已生成: {args.output}")
        return 0

    except Exception as e:
        print(f"错误: {str(e)}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    import sys
    sys.exit(main())