#!/usr/bin/env python3
"""
HTML 报告分析数据回填脚本
将 AI 分析结果回填到脚本生成的 HTML 报告中的 {{PLACEHOLDER}} 占位符。
用法: python3 backfill_html.py <html_path> --analysis-json '<json>'
      或通过 stdin 传入 JSON: echo '<json>' | python3 backfill_html.py <html_path>
"""

import sys
import os
import json
import argparse


def backfill(html_path: str, analysis: dict) -> None:
    """读取 HTML 文件，替换分析占位符，写回文件"""
    if not os.path.exists(html_path):
        print(f"[error] HTML 文件不存在: {html_path}", file=sys.stderr)
        sys.exit(1)

    with open(html_path, "r", encoding="utf-8") as f:
        html = f.read()

    # 统计栏比例
    ratio_map = {
        "{{POSITIVE_RATIO}}": str(analysis.get("positive_ratio", "--")),
        "{{NEGATIVE_RATIO}}": str(analysis.get("negative_ratio", "--")),
        "{{DEMAND_RATIO}}": str(analysis.get("demand_ratio", "--")),
        "{{COMPETITOR_RATIO}}": str(analysis.get("competitor_ratio", "--")),
    }

    for key, val in ratio_map.items():
        html = html.replace(key, val)

    # 摘要卡片内容
    summary_map = {
        "{{SUMMARY_POSITIVE}}": analysis.get("positive_summary", ""),
        "{{SUMMARY_NEGATIVE}}": analysis.get("negative_summary", ""),
        "{{SUMMARY_DEMAND}}": analysis.get("demand_summary", ""),
        "{{SUMMARY_COMPETITOR}}": analysis.get("competitor_summary", ""),
    }

    for key, val in summary_map.items():
        html = html.replace(key, val)

    with open(html_path, "w", encoding="utf-8") as f:
        f.write(html)

    print(f"[backfill] 分析数据已回填到: {html_path}", file=sys.stderr)


def main():
    parser = argparse.ArgumentParser(description="HTML 报告分析数据回填")
    parser.add_argument("html_path", help="HTML 报告文件路径")
    parser.add_argument(
        "--analysis-json", dest="analysis_json", type=str, default=None,
        help='分析数据 JSON 字符串，格式: {"positive_ratio":45,"positive_summary":"<ul>...</ul>",...}',
    )

    args = parser.parse_args()

    # 优先从 --analysis-json 参数读取，其次从 stdin 读取
    if args.analysis_json:
        try:
            analysis = json.loads(args.analysis_json)
        except json.JSONDecodeError as e:
            print(f"[error] JSON 解析失败: {e}", file=sys.stderr)
            sys.exit(1)
    else:
        # 从 stdin 读取 JSON
        try:
            raw = sys.stdin.read()
            analysis = json.loads(raw) if raw.strip() else {}
        except json.JSONDecodeError as e:
            print(f"[error] stdin JSON 解析失败: {e}", file=sys.stderr)
            sys.exit(1)

    if not analysis:
        print("[warn] 未提供分析数据，跳过回填", file=sys.stderr)
        return

    backfill(args.html_path, analysis)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
快手评论分析 - 合并报告生成脚本
将多页评论数据合并生成一份完整的 HTML 报告，
包含所有评论和累计分析。超过 3 页时自动折叠。

用法: echo '<json_array>' | python3 consolidate_report.py "<opusId>" --analysis-json '<json>'
      或: python3 consolidate_report.py "<opusId>" --pages-json '<json_array>' --analysis-json '<json>'
"""

import sys
import os
import json
import argparse
import subprocess
from datetime import datetime

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_PATH = os.path.join(SCRIPT_DIR, "..", "assets", "consolidate_report_template.html")


def escape_html(text: str) -> str:
    return (text or "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")


def build_comment_rows(comments: list) -> str:
    """根据评论列表生成 HTML 表格行"""
    rows = []
    for c in comments:
        is_top = c.get("is_top", False)
        row_class = ' class="top-comment"' if is_top else ""
        pin_badge = '<span class="top-badge">📌 置顶</span>' if is_top else ""

        avatar = c.get("user_avatar", "") or ""
        name = escape_html(c.get("user_name", ""))
        content = escape_html(c.get("content", ""))
        like = c.get("like_count", 0) or 0
        reply = c.get("reply_count", 0) or 0
        time_str = (c.get("create_time", "") or "")[5:16]
        ip = escape_html(c.get("ip_location", ""))

        row = (
            f'<tr{row_class}>'
            f'<td>'
            f'<div class="user-cell">'
            f'<img src="{avatar}" class="user-avatar" alt="" onerror="this.style.display=\'none\'" referrerpolicy="no-referrer">'
            f'<span class="user-name">{name}{pin_badge}</span>'
            f'</div>'
            f'</td>'
            f'<td class="content-cell">{content}</td>'
            f'<td class="num-cell">{like}</td>'
            f'<td class="num-cell">{reply}</td>'
            f'<td class="time-cell">{time_str}</td>'
            f'<td class="ip-cell">{ip}</td>'
            f'</tr>'
        )
        rows.append(row)
    return "\n".join(rows)


def build_page_sections(pages: list, max_visible: int = 3) -> tuple:
    """
    生成页面 HTML 片段和折叠切换按钮。
    pages: [{"page": 1, "total": 31, "comments": [...]}, ...]
    返回 (page_sections_html, collapse_toggle_html)
    """
    visible_count = 0
    visible_sections = []
    collapsed_sections = []

    # 过滤空页
    pages = [p for p in pages if p.get("comments") and len(p["comments"]) > 0]
    total_pages = len(pages)

    for i, p in enumerate(pages):
        page_num = p.get("page", i + 1)
        total = p.get("total", len(p.get("comments", [])))
        comments = p.get("comments", [])

        table_rows = build_comment_rows(comments)

        section_html = (
            f'<div class="page-section">'
            f'<h3>📄 第 {page_num} 页 '
            f'<span class="page-badge">{total} 条</span>'
            f'</h3>'
            f'<div class="table-wrapper">'
            f'<table class="comment-table">'
            f'<thead>'
            f'<tr>'
            f'<th style="width: 160px;">评论人</th>'
            f'<th>评论内容</th>'
            f'<th style="width: 70px; text-align: right;">👍 点赞</th>'
            f'<th style="width: 70px; text-align: right;">💬 回复</th>'
            f'<th style="width: 110px;">时间</th>'
            f'<th style="width: 80px;">IP属地</th>'
            f'</tr>'
            f'</thead>'
            f'<tbody>'
            f'{table_rows}'
            f'</tbody>'
            f'</table>'
            f'</div>'
            f'</div>'
        )

        if total_pages <= max_visible or page_num <= max_visible:
            visible_sections.append(section_html)
        else:
            collapsed_sections.append(section_html)

    sections_html = "\n".join(visible_sections)

    # 折叠区域
    if collapsed_sections:
        hidden_count = sum(
            p.get("total", len(p.get("comments", [])))
            for p in pages[max_visible:]
        )
        toggle_html = (
            f'<div class="collapse-container" id="collapseToggle">'
            f'<p style="color: var(--text-secondary); margin-bottom: 0.6rem; font-size: 0.85rem;">'
            f'⚠️ 评论页数较多，已折叠第 {max_visible + 1}-{total_pages} 页（共 {hidden_count} 条）</p>'
            f'<button class="collapse-toggle" onclick="toggleCollapsed()">'
            f'📂 展开全部评论'
            f'</button>'
            f'</div>'
            f'<div class="collapsed-pages" id="collapsedPages">'
            + "\n".join(collapsed_sections) +
            f'</div>'
        )
    else:
        toggle_html = ""

    return sections_html, toggle_html


def generate_consolidated_report(
    opus_id: str,
    pages: list,
    analysis: dict,
    output_dir: str = None,
) -> str:
    template_path = os.path.normpath(TEMPLATE_PATH)
    if not os.path.exists(template_path):
        print(f"[error] 模板文件不存在: {template_path}", file=sys.stderr)
        sys.exit(1)

    with open(template_path, "r", encoding="utf-8") as f:
        html = f.read()

    # 过滤空页并合并所有评论
    pages = [p for p in pages if p.get("comments") and len(p["comments"]) > 0]
    all_comments = []
    for p in pages:
        all_comments.extend(p.get("comments", []))

    total_pages = len(pages)
    total_comments = len(all_comments)
    total_likes = sum(c.get("like_count", 0) or 0 for c in all_comments)
    now = datetime.now()

    # 生成页面区域
    page_sections, collapse_toggle = build_page_sections(pages)

    replacements = {
        "{{OPUS_ID}}": escape_html(opus_id),
        "{{DATE}}": now.strftime("%Y-%m-%d"),
        "{{TOTAL_COMMENTS}}": str(total_comments),
        "{{TOTAL_LIKES}}": str(total_likes),
        "{{TOTAL_PAGES}}": str(total_pages),
        "{{TIMESTAMP}}": now.strftime("%Y-%m-%d %H:%M:%S"),
        "{{PAGE_SECTIONS}}": page_sections,
        "{{COLLAPSE_TOGGLE}}": collapse_toggle,
        "{{POSITIVE_RATIO}}": str(analysis.get("positive_ratio", "--")),
        "{{NEGATIVE_RATIO}}": str(analysis.get("negative_ratio", "--")),
        "{{DEMAND_RATIO}}": str(analysis.get("demand_ratio", "--")),
        "{{COMPETITOR_RATIO}}": str(analysis.get("competitor_ratio", "--")),
        "{{SUMMARY_POSITIVE}}": analysis.get("positive_summary", ""),
        "{{SUMMARY_NEGATIVE}}": analysis.get("negative_summary", ""),
        "{{SUMMARY_DEMAND}}": analysis.get("demand_summary", ""),
        "{{SUMMARY_COMPETITOR}}": analysis.get("competitor_summary", ""),
    }

    for key, val in replacements.items():
        html = html.replace(key, val)

    # 添加 JavaScript 折叠逻辑
    collapse_js = """
<script>
function toggleCollapsed() {
    var collapsed = document.getElementById('collapsedPages');
    var btn = document.getElementById('collapseToggle').querySelector('.collapse-toggle');
    if (collapsed.classList.contains('visible')) {
        collapsed.classList.remove('visible');
        btn.textContent = '📂 展开全部评论';
    } else {
        collapsed.classList.add('visible');
        btn.textContent = '📁 收起';
    }
}
</script>
"""
    html = html.replace("</body>", collapse_js + "\n</body>")

    if output_dir:
        out_dir = os.path.expanduser(output_dir)
    else:
        out_dir = os.path.expanduser("~/Downloads/QoderReports")
    os.makedirs(out_dir, exist_ok=True)

    filename = f"快手评论分析_{opus_id}_全部{total_pages}页.html"
    file_path = os.path.join(out_dir, filename)

    with open(file_path, "w", encoding="utf-8") as f:
        f.write(html)

    print(f"[consolidate] 合并报告已生成: {file_path}", file=sys.stderr)
    return file_path


def main():
    parser = argparse.ArgumentParser(description="快手评论合并报告生成")
    parser.add_argument("opus_id", help="快手作品 opusId")
    parser.add_argument(
        "--pages-json", dest="pages_json", type=str, default=None,
        help='多页数据 JSON 字符串，格式: [{"page":1,"total":20,"comments":[...]},...]',
    )
    parser.add_argument(
        "--analysis-json", dest="analysis_json", type=str, default=None,
        help='累计分析数据 JSON',
    )
    parser.add_argument(
        "--output-dir", dest="output_dir", type=str, default=None,
        help="HTML 输出目录",
    )

    args = parser.parse_args()

    # 读取 pages 数据
    if args.pages_json:
        pages = json.loads(args.pages_json)
    else:
        raw = sys.stdin.read()
        pages = json.loads(raw) if raw.strip() else []

    if not pages:
        print("[error] 未提供评论数据", file=sys.stderr)
        sys.exit(1)

    # 读取分析数据
    if args.analysis_json:
        analysis = json.loads(args.analysis_json)
    else:
        analysis = {}

    html_path = generate_consolidated_report(
        opus_id=args.opus_id,
        pages=pages,
        analysis=analysis,
        output_dir=args.output_dir,
    )

    print(json.dumps({"html_path": html_path}, ensure_ascii=False))

    # 自动在浏览器中打开
    subprocess.run(["open", html_path])


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
快手评论分析脚本
调用 Redfox API 获取快手作品一级评论数据，同步生成 HTML 报告
用法: python3 kuaishou_comment_search.py "<opusId>" [--cursor ""] [--page 1] [--no-html] [--output-dir ~/Downloads/QoderReports]
"""

import sys
import os
import json
import argparse
import urllib.request
import urllib.error
from datetime import datetime

API_URL = "https://redfox.hk/story/api/ks/ability/commentList"

# 脚本所在目录，用于定位模板
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_PATH = os.path.join(SCRIPT_DIR, "..", "assets", "report_template.html")


def get_api_key() -> str:
    val = os.environ.get("REDFOX_API_KEY", "")
    if not val:
        print("[error] 未找到环境变量 REDFOX_API_KEY，请确认已设置 API Key", file=sys.stderr)
        print("[hint] 获取 API Key: https://redfox.hk/settings/api-keys?source=github", file=sys.stderr)
        print("[hint] 配置: export REDFOX_API_KEY=ak_xxxx...", file=sys.stderr)
        sys.exit(1)
    return val


def call_api(opus_id: str, cursor: str, api_key: str) -> dict:
    """单次调用评论接口，返回原始 JSON 数据"""
    payload = json.dumps({
        "opusId": opus_id,
        "cursor": cursor or "",
        "source": "快手评论分析-GitHub",
    }).encode("utf-8")

    req = urllib.request.Request(
        API_URL,
        data=payload,
        headers={
            "Content-Type": "application/json",
            "X-API-Key": api_key,
            "User-Agent": "QoderWork/1.0",
        },
        method="POST",
    )

    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            result = json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        print(f"[error] HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"[error] 网络请求失败: {e.reason}", file=sys.stderr)
        sys.exit(1)
    except (json.JSONDecodeError, KeyError, TypeError) as e:
        print(f"[error] 数据解析异常: {e}", file=sys.stderr)
        sys.exit(1)

    code = result.get("code")
    if code != 2000:
        print(f"[error] 接口返回错误: code={code}, msg={result.get('msg', '未知')}", file=sys.stderr)
        sys.exit(1)

    return result


def format_comment(raw: dict) -> dict:
    """将 API 返回的原始评论格式化为统一结构

    API 返回字段（data.comments[]）：
    cid, content, likeNum, replyNum, createTime,
    area, nickname, avatar, uid, bottomTags
    """
    user_uid = raw.get("uid", "") or ""
    nickname = (raw.get("nickname", "") or "").strip()
    avatar = raw.get("avatar", "") or ""

    # 置顶判断：bottomTags 中包含 "top_comment"
    bottom_tags_str = raw.get("bottomTags", "") or ""
    is_top = "top_comment" in bottom_tags_str

    return {
        "comment_id": raw.get("cid", ""),
        "content": (raw.get("content", "") or "").strip(),
        "like_count": raw.get("likeNum", 0) or 0,
        "reply_count": raw.get("replyNum", 0) or 0,
        "create_time": raw.get("createTime", "") or "",
        "ip_location": raw.get("area", "") or "",
        "user_name": nickname,
        "user_avatar": avatar,
        "user_id": user_uid,
        "is_top": is_top,
    }


def fetch_comments(opus_id: str, cursor: str, api_key: str) -> tuple:
    """
    单次调用接口获取当前页评论数据（每次仅调用一次 API）。
    返回 (comments_list, has_next, next_cursor)
    """
    result = call_api(opus_id, cursor, api_key)
    data = result.get("data") or {}
    page_comments = data.get("comments") or []
    if not isinstance(page_comments, list):
        page_comments = []
    all_comments = [format_comment(c) for c in page_comments]

    # 判断是否有下一页：cursor 有值且不为终止标识 "no_more"
    raw_cursor = data.get("cursor", "") or ""
    has_next = bool(raw_cursor) and raw_cursor != "no_more"
    next_cursor = raw_cursor

    return all_comments, has_next, next_cursor


def escape_html(text: str) -> str:
    """HTML 实体转义"""
    return (text or "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")


def build_comment_rows(comments: list) -> str:
    """根据评论列表生成 HTML 表格行"""
    rows = []
    for c in comments:
        is_top = c.get("is_top", False)
        row_class = ' class="top-comment"' if is_top else ""
        pin_badge = '<span class="top-badge">📌 置顶</span>' if is_top else ""

        avatar = c.get("user_avatar", "") or ""
        name = escape_html(c.get("user_name", ""))
        content = escape_html(c.get("content", ""))
        like = c.get("like_count", 0) or 0
        reply = c.get("reply_count", 0) or 0
        time_str = (c.get("create_time", "") or "")[5:16]  # YYYY-MM-DD HH:MM:SS → MM-DD HH:MM
        ip = escape_html(c.get("ip_location", ""))

        row = (
            f'<tr{row_class}>'
            f'<td>'
            f'<div class="user-cell">'
            f'<img src="{avatar}" class="user-avatar" alt="" onerror="this.style.display=\'none\'" referrerpolicy="no-referrer">'
            f'<span class="user-name">{name}{pin_badge}</span>'
            f'</div>'
            f'</td>'
            f'<td class="content-cell">{content}</td>'
            f'<td class="num-cell">{like}</td>'
            f'<td class="num-cell">{reply}</td>'
            f'<td class="time-cell">{time_str}</td>'
            f'<td class="ip-cell">{ip}</td>'
            f'</tr>'
        )
        rows.append(row)
    return "\n".join(rows)


def generate_html_report(opus_id: str, current_page: int, comments: list, output_dir: str = None) -> str:
    """
    读取 HTML 模板，填充评论数据，生成报告文件。
    返回生成的 HTML 文件绝对路径。
    """
    template_path = os.path.normpath(TEMPLATE_PATH)
    if not os.path.exists(template_path):
        print(f"[warn] 模板文件不存在: {template_path}，跳过 HTML 生成", file=sys.stderr)
        return ""

    with open(template_path, "r", encoding="utf-8") as f:
        html = f.read()

    total = len(comments)
    now = datetime.now()

    total_likes = sum(c.get("like_count", 0) or 0 for c in comments)

    replacements = {
        "{{OPUS_ID}}": escape_html(opus_id),
        "{{DATE}}": now.strftime("%Y-%m-%d"),
        "{{TOTAL_COMMENTS}}": str(total),
        "{{COMMENT_ROWS}}": build_comment_rows(comments),
        "{{TIMESTAMP}}": now.strftime("%Y-%m-%d %H:%M:%S"),
        "{{TOTAL_LIKES}}": str(total_likes),
        "{{PAGE}}": str(current_page),
    }

    for key, val in replacements.items():
        html = html.replace(key, val)

    if output_dir:
        out_dir = os.path.expanduser(output_dir)
    else:
        out_dir = os.path.expanduser("~/Downloads/QoderReports")
    os.makedirs(out_dir, exist_ok=True)

    filename = f"快手评论分析_{opus_id}_p{current_page}.html"
    file_path = os.path.join(out_dir, filename)

    with open(file_path, "w", encoding="utf-8") as f:
        f.write(html)

    print(f"[html] HTML 报告已生成: {file_path}", file=sys.stderr)
    return file_path


def main():
    parser = argparse.ArgumentParser(description="快手评论分析")
    parser.add_argument("opus_id", help="快手作品 opusId")
    parser.add_argument(
        "--cursor", dest="cursor", type=str, default="",
        help="游标（首页传空字符串，次页传上一页返回的 nextCursor）",
    )
    parser.add_argument(
        "--page", dest="page", type=int, default=1,
        help="当前页码（默认 1）",
    )
    parser.add_argument(
        "--no-html", dest="no_html", action="store_true",
        help="跳过 HTML 报告生成",
    )
    parser.add_argument(
        "--output-dir", dest="output_dir", type=str, default=None,
        help="HTML 输出目录（默认 ~/Downloads/QoderReports）",
    )

    args = parser.parse_args()

    opus_id = args.opus_id.strip()
    if not opus_id:
        print("[error] opusId 不能为空", file=sys.stderr)
        sys.exit(1)

    api_key = get_api_key()

    comments, has_next, next_cursor = fetch_comments(opus_id, args.cursor, api_key)

    total = len(comments)
    current_page = args.page

    output = {
        "opus_id": opus_id,
        "current_page": current_page,
        "cursor": args.cursor,
        "next_cursor": next_cursor,
        "total_fetched": total,
        "has_next": has_next,
        "comments": comments,
        "total_count": total,
    }

    if not args.no_html:
        html_path = generate_html_report(
            opus_id=opus_id,
            current_page=current_page,
            comments=comments,
            output_dir=args.output_dir,
        )
        output["html_path"] = html_path

    print(json.dumps(output, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()