Wechat Original Hot

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
公众号原创爆款文章获取脚本

功能：
1. 调用API获取公众号原创爆款文章数据
2. 按阅读量排序
3. 输出TOP榜单列表（Markdown格式，含链接）
4. 支持分类查询和时间区间查询

使用方法：
python fetch_articles.py --type "科技数码" --source "公众号文章原创之王-GitHub" --start_date "2026-05-03" --end_date "2026-05-04"
python fetch_articles.py --type "总排名" --source "公众号文章原创之王-GitHub"  # 自动判断时间
python fetch_articles.py  # 默认：总排名，自动判断时间
"""

import argparse
import json
import os
import sys
import ssl
import urllib.request
import urllib.error
from datetime import datetime, timedelta


# ==================== 分类映射 ====================

CATEGORY_MAPPING = {
    "人文资讯": ["人文", "文化", "历史", "哲学", "文学", "艺术", "人文社科"],
    "知识百科": ["知识", "百科", "科普", "冷知识", "常识", "百科全书"],
    "健康养生": ["健康", "养生", "保健", "医疗", "中医", "健身", "营养", "健康生活"],
    "时尚潮流": ["时尚", "潮流", "穿搭", "美妆", "时尚穿搭", "流行趋势"],
    "美食餐饮": ["美食", "餐饮", "美食推荐", "菜谱", "烹饪", "吃货", "饮食"],
    "乐活生活": ["乐活", "生活", "生活方式", "生活品质", "品质生活", "生活技巧"],
    "旅游出行": ["旅游", "出行", "旅行", "攻略", "景点", "自驾游", "旅游攻略"],
    "搞笑幽默": ["搞笑", "幽默", "段子", "笑话", "娱乐", "开心", "趣事"],
    "情感心理": ["情感", "心理", "情感故事", "恋爱", "婚姻", "亲情", "友情", "心理辅导"],
    "体育娱乐": ["体育", "娱乐", "运动", "明星", "电影", "音乐", "综艺", "体育赛事"],
    "美容美体": ["美容", "美体", "护肤", "减肥", "瘦身", "美容护肤", "塑形"],
    "文摘精选": ["文摘", "精选", "好文", "美文", "精选文章", "优秀文章"],
    "民生资讯": ["民生", "社会", "新闻", "时事", "热点", "社会新闻", "民生热点"],
    "财富理财": ["财富", "理财", "投资", "金融", "基金", "股票", "保险", "财商"],
    "科技数码": ["科技", "数码", "互联网", "手机", "电脑", "科技新闻", "数码产品"],
    "创投商业": ["创投", "商业", "创业", "投资", "商业模式", "创业故事", "商业财经"],
    "汽车交通": ["汽车", "交通", "购车", "用车", "汽车评测", "交通出行"],
    "房产楼市": ["房产", "楼市", "买房", "卖房", "房产投资", "房地产", "房价"],
    "职场发展": ["职场", "职业", "工作", "求职", "职场技巧", "职业发展", "职场故事"],
    "教育考试": ["教育", "考试", "学习", "培训", "高考", "考研", "教育培训", "学习方法"],
    "学术研究": ["学术", "研究", "论文", "科研", "学术前沿", "研究成果"],
    "企业品牌": ["企业", "品牌", "公司", "管理", "企业文化", "品牌故事", "企业案例"],
    "总排名": ["总排名", "全部", "所有分类", "综合排名", "总榜"]
}


def match_category(user_input: str) -> str:
    """
    根据用户输入匹配分类

    Args:
        user_input: 用户输入的文本

    Returns:
        匹配的标准分类名称，默认返回"总排名"
    """
    if not user_input:
        return "总排名"

    user_input_lower = user_input.lower().strip()

    # 1. 精确匹配
    for category in CATEGORY_MAPPING.keys():
        if user_input_lower == category.lower():
            return category

    # 2. 包含匹配
    for category in CATEGORY_MAPPING.keys():
        if category.lower() in user_input_lower or user_input_lower in category.lower():
            return category

    # 3. 关键词匹配
    for category, keywords in CATEGORY_MAPPING.items():
        for keyword in keywords:
            if keyword.lower() in user_input_lower:
                return category

    # 默认返回总排名
    return "总排名"


# ==================== API Key 获取 ====================

def get_api_key():
    """从当前环境变量获取 REDFOX_API_KEY"""
    api_key = os.getenv("REDFOX_API_KEY")
    if not api_key:
        print("❌ 未找到 REDFOX_API_KEY，请配置环境变量：export REDFOX_API_KEY=<你的apikey>", file=sys.stderr)
        sys.exit(1)
    return api_key


# ==================== 接口调用 ====================

def fetch_articles_api(url: str, params: dict, api_key: str, timeout: int = 30) -> dict:
    """
    使用原生 urllib.request 发 HTTPS POST 请求（verify=False）

    Args:
        url: API 地址
        params: 请求参数（JSON body）
        api_key: X-API-KEY 认证密钥
        timeout: 超时时间（秒）

    Returns:
        API 响应数据（dict）
    """
    headers = {
        "Content-Type": "application/json",
        "X-API-KEY": api_key
    }

    body = json.dumps(params, ensure_ascii=False)
    data = body.encode("utf-8")

    req = urllib.request.Request(url, data=data, headers=headers, method="POST")

    ssl_ctx = ssl.create_default_context()
    ssl_ctx.check_hostname = False
    ssl_ctx.verify_mode = ssl.CERT_NONE

    try:
        with urllib.request.urlopen(req, context=ssl_ctx, timeout=timeout) as resp:
            result = json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        raise Exception(f"HTTP请求失败: {e.code}, {e.read().decode('utf-8', errors='replace')}")
    except urllib.error.URLError as e:
        raise Exception(f"请求失败: {e.reason}")

    return result


def fetch_articles_by_category(type: str, source: str, start_date: str = "", end_date: str = "") -> dict:
    """
    调用新接口获取文章数据

    Args:
        type: 分类名称
        source: 数据源
        start_date: 开始日期（YYYY-MM-DD）
        end_date: 结束日期（YYYY-MM-DD）

    Returns:
        API 响应数据
    """
    url = "https://redfox.hk/story/api/cozeSkill/getWxDataByCategoryAndTime"

    # 获取 API Key（环境变量 > shell配置文件 > 提示用户配置）
    api_key = get_api_key()

    params = {
        "type": type,
        "source": source
    }

    if start_date:
        params["startDate"] = start_date
    if end_date:
        params["endDate"] = end_date

    print(f"正在获取原创爆款文章推荐...")
    print(f"分类: {type}")
    print(f"数据源: {source}")
    if start_date:
        print(f"开始日期: {start_date}")
    if end_date:
        print(f"结束日期: {end_date}")
    print("-" * 60)

    data = fetch_articles_api(url, params, api_key)

    if data.get("code") != 2000:
        raise Exception(f"API错误: {data.get('msg', '未知错误')}")

    return data


# ==================== 数据处理 ====================

def parse_count_to_int(count_str: str) -> int:
    """解析阅读数字符串为整数"""
    if not count_str:
        return 0

    count_str = str(count_str).strip().replace(",", "")

    if "10w+" in count_str.lower() or "10万+" in count_str:
        return 100000
    elif "w+" in count_str.lower() or "万+" in count_str:
        # 处理 "1w+", "5w+" 等格式
        try:
            num_str = count_str.lower().replace("w+", "").replace("万+", "")
            num = float(num_str)
            return int(num * 10000)
        except:
            return 0
    elif "w" in count_str.lower() or "万" in count_str:
        try:
            num = float(count_str.lower().replace("w", "").replace("万", ""))
            return int(num * 10000)
        except:
            return 0
    else:
        try:
            return int(float(count_str))
        except:
            return 0


def get_reading_score(article: dict) -> int:
    """获取阅读量作为排序依据"""
    clicks_count = parse_count_to_int(article.get("clicksCount", "0"))
    return int(clicks_count or 0)


def process_articles(data: dict) -> list:
    """
    处理文章数据，按阅读量排序

    Args:
        data: API 响应数据

    Returns:
        排序后的文章列表
    """
    articles = data.get("data", {}).get("originalRank", [])

    if not articles:
        return []

    # 按阅读量排序
    articles.sort(key=get_reading_score, reverse=True)

    return articles


# ==================== 时间计算 ====================

def get_query_date_range() -> tuple:
    """
    根据当前时间判断查询日期范围

    数据每日 19:30 更新，更新前一天（T-1）的数据。
    - 当前时间 < 19:30：查询 T-2 数据
    - 当前时间 >= 19:30：查询 T-1 数据

    Returns:
        (start_date, end_date, query_date_display, update_date_display)
    """
    now = datetime.now()
    current_hour = now.hour
    current_minute = now.minute

    if current_hour < 19 or (current_hour == 19 and current_minute < 30):
        # 当前时间 < 19:30，查询 T-2 数据
        query_date = now - timedelta(days=2)  # 前天
        update_date = now - timedelta(days=1)  # 昨天
    else:
        # 当前时间 >= 19:30，查询 T-1 数据
        query_date = now - timedelta(days=1)  # 昨天
        update_date = now  # 今天

    start_date = query_date.strftime("%Y-%m-%d")
    end_date = (query_date + timedelta(days=1)).strftime("%Y-%m-%d")
    query_date_display = query_date.strftime("%Y年%m月%d日")
    update_date_display = update_date.strftime("%Y年%m月%d日")

    return start_date, end_date, query_date_display, update_date_display


def get_recent_days_range(days: int = 7) -> tuple:
    """
    获取最近N天的日期范围

    Args:
        days: 天数（默认7天）

    Returns:
        (start_date, end_date, date_range_display)
    """
    now = datetime.now()
    end_date = now
    start_date = now - timedelta(days=days-1)  # 包含今天，所以是days-1

    start_date_str = start_date.strftime("%Y-%m-%d")
    end_date_str = end_date.strftime("%Y-%m-%d")
    date_range_display = f"{start_date.strftime('%Y年%m月%d日')}至{end_date.strftime('%Y年%m月%d日')}"

    return start_date_str, end_date_str, date_range_display


# ==================== 输出格式化 ====================

def format_count(count_str: str) -> str:
    """格式化阅读数显示"""
    if not count_str:
        return "0"

    count_str = str(count_str).strip()

    # 保留原始的 w+ 或 万+ 格式
    if "10w+" in count_str.lower() or "10万+" in count_str or "10W+" in count_str:
        return "10w+"
    elif "w+" in count_str.lower() or "万+" in count_str:
        # 保留原始格式，如 "1w+", "5w+"
        return count_str.lower().replace("万+", "w+")

    count = parse_count_to_int(count_str)
    if count >= 10000:
        return f"{count/10000:.1f}w"
    else:
        return str(count)


def output_table(articles: list, limit: int = 20, mode: str = "preview", category: str = "总排名"):
    """
    输出文章表格

    Args:
        articles: 文章列表
        limit: 显示条数
        mode: 输出模式（preview/full）
        category: 分类名称
    """
    total = len(articles)
    display_count = min(limit, total) if mode == "preview" else total
    display_articles = articles[:display_count]

    # 输出表格
    print("\n| 序号 | 作者 | 标题 | 阅读数 |")
    print("|------|------|------|--------|")

    for i, article in enumerate(display_articles, 1):
        author = article.get("userName", "-")
        title = article.get("title", "-")
        clicks = format_count(article.get("clicksCount", "0"))

        account_id = article.get("accountId", "")
        ori_url = article.get("oriUrl", "")

        # 构建链接
        author_link = f"https://open.weixin.qq.com/qr/code?username={account_id}" if account_id else ""
        title_link = ori_url if ori_url else ""

        # 输出行
        if author_link:
            author_display = f"[{author}]({author_link})"
        else:
            author_display = author

        if title_link:
            title_display = f"[{title}]({title_link})"
        else:
            title_display = title

        print(f"| {i} | {author_display} | {title_display} | {clicks} |")

    print("\n导出功能：输出生成HTML榜单页面，表格内容支持导出 PDF 格式，自动生成并打开")

    # 文章少于10篇时的提示
    if total < 10:
        category_display = category if category != "总排名" else "综合"
        print(f"\n💡 {category_display}赛道10w+文章较少，您可以拓展过去30天或者看看综合10w+文章~")

    if mode == "preview" and total > limit:
        print(f"\n共获取到{total}条爆款原创热门文章,当前展示前{limit}条。")
        print(f"\n📬 订阅服务")
        print("是否需要订阅具体赛道的账号表现？我们支持：")
        print("人文资讯、知识百科、健康养生、时尚潮流、美食餐饮、乐活生活、旅游出行、搞笑幽默、情感心理、体育娱乐、美容美体、文摘精选、民生资讯、财富理财、科技数码、创投商业、汽车交通、房产楼市、职场发展、教育考试、学术研究、企业品牌、总排名")
        print("订阅推送 — 每天19点30分推送最新公众号原创文章")
        print("暂不需要 — 仅本次查询")
    else:
        print(f"\n共获取到{total}条爆款原创热门文章。")


# ==================== 主函数 ====================

def main():
    parser = argparse.ArgumentParser(description="获取公众号原创爆款文章")
    parser.add_argument("--type", default="", help="分类名称（如'科技数码'，默认'总排名'）")
    parser.add_argument("--source", default="公众号文章原创之王-GitHub", help="数据源")
    parser.add_argument("--start_date", default="", help="开始日期（YYYY-MM-DD）")
    parser.add_argument("--end_date", default="", help="结束日期（YYYY-MM-DD）")
    parser.add_argument("--recent", type=int, default=0, help="最近N天（如7表示最近7天）")
    parser.add_argument("--limit", type=int, default=20, help="显示条数（默认20）")
    parser.add_argument("--mode", default="preview", choices=["preview", "full"], help="输出模式")
    parser.add_argument("--temp_file", default="temp_articles.json", help="临时JSON文件路径")
    parser.add_argument("--query_intent", default="", help="查询意图（today/yesterday，用于判断是否需要提示）")

    args = parser.parse_args()

    # 匹配分类
    category = match_category(args.type) if args.type else "总排名"

    # 确定日期范围
    if args.recent > 0:
        # 用户查询最近N天
        start_date, end_date, date_range_display = get_recent_days_range(args.recent)
        query_date_display = date_range_display
        is_specific_date = False
        is_recent_query = True
    elif args.start_date:
        # 用户指定了日期
        start_date = args.start_date
        end_date = args.end_date if args.end_date else (datetime.strptime(start_date, "%Y-%m-%d") + timedelta(days=1)).strftime("%Y-%m-%d")
        query_date_display = datetime.strptime(start_date, "%Y-%m-%d").strftime("%Y年%m月%d日")
        is_specific_date = True
        is_recent_query = False
    else:
        # 自动判断日期
        start_date, end_date, query_date_display, update_date_display = get_query_date_range()
        is_specific_date = False
        is_recent_query = False

    # 判断用户查询意图是否为"今日"或"昨日"
    query_intent = args.query_intent.lower() if args.query_intent else ""
    need_prompt = False
    if query_intent in ["today", "今日", "今天"]:
        # 用户想查询今日数据
        need_prompt = True
        intent_date_str = "今天"
    elif query_intent in ["yesterday", "昨日", "昨天"]:
        # 用户想查询昨日数据
        need_prompt = True
        intent_date_str = "昨天"

    # 调用接口
    try:
        data = fetch_articles_by_category(category, args.source, start_date, end_date)
    except Exception as e:
        print(f"❌ 错误: {str(e)}")
        sys.exit(1)

    # 处理数据
    articles = process_articles(data)

    if not articles:
        print("❌ 未获取到文章数据")
        sys.exit(0)

    # 保存临时文件
    with open(args.temp_file, 'w', encoding='utf-8') as f:
        json.dump({"articles": articles}, f, ensure_ascii=False, indent=2)
    print(f"✅ 数据已保存到临时文件: {args.temp_file}")

    # 输出数据说明
    print(f"\n💡 数据说明")
    print(f"公众号原创文章推荐将在每日19点30分准时更新昨日文章数据，以下数据为获取时间时的快照，和实时数据有所差别。")

    # 判断数据更新状态（所有情况统一处理）
    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
    current_hour = datetime.now().hour
    current_minute = datetime.now().minute
    if current_hour < 19 or (current_hour == 19 and current_minute < 30):
        # 19:30前，最新数据是T-2（前天）
        latest_date = today - timedelta(days=2)
        latest_date_str = "前天"
    else:
        # 19:30后，最新数据是T-1（昨天）
        latest_date = today - timedelta(days=1)
        latest_date_str = "昨天"

    # 回溯日期（30天前）
    earliest_date = today - timedelta(days=30)

    # 判断是否需要提示（数据查询日期和用户询问日期不一致）
    need_date_prompt = False
    prompt_message = ""

    if is_recent_query:
        # 最近N天查询，检查查询的结束日期是否晚于最新日期
        # 解析 query_date_display 获取结束日期
        if "至" in query_date_display:
            end_date_str = query_date_display.split("至")[1].replace("年", "-").replace("月", "-").replace("日", "")
            try:
                query_end_date = datetime.strptime(end_date_str.strip(), "%Y-%m-%d")
                if query_end_date > latest_date:
                    need_date_prompt = True
                    prompt_message = f"\n非常抱歉🙏，最新的是{latest_date_str}的数据，我将为您查询最接近您需求的时间范围。"
            except:
                pass

        print(f"\n📊 原创爆文推荐")
        print(f"{query_date_display}的原创爆款文章")
    elif is_specific_date:
        # 指定日期查询
        query_date = datetime.strptime(start_date, "%Y-%m-%d")

        if query_date > latest_date:
            # 用户查询未更新日期的榜单（查询日期晚于最新日期）
            need_date_prompt = True
            prompt_message = f"\n非常抱歉🙏，最新的是{latest_date_str}的数据，我将为您查询最接近您需求的{query_date_display}原创文章。"
        elif query_date < earliest_date:
            # 用户查询时间早于回溯日期
            need_date_prompt = True
            prompt_message = f"\n非常抱歉🙏，目前最多支持回溯「过去30天」，我将为您查询最接近您需求的时间范围~"

        print(f"\n📊 原创爆文推荐")
        print(f"{query_date_display}当天的原创爆款文章")
    else:
        # 默认查询，检查是否需要提示
        if need_prompt:
            # 用户想查询"今日"或"昨日"，但数据还没更新
            need_date_prompt = True
            prompt_message = f"\n非常抱歉🙏，最新的是{latest_date_str}的数据，我将为您查询最接近您需求的{query_date_display}原创文章。"

        print(f"\n📊 原创爆文推荐")
        print(f"{query_date_display}当天的原创爆款文章")

    # 统一输出提示信息
    if need_date_prompt:
        print(prompt_message)

    # 输出表格
    output_table(articles, args.limit, args.mode, category)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
公众号原创爆款文章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} · 公众号原创爆款文章</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} · 原创爆款文章</h1>
            <p class="brand-subtitle">每日推送公众号原创爆款内容，解析流量密码</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">公众号原创爆款文章，每日更新最新爆文内容</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="生成公众号原创爆款文章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())