Douyin Batch Download

# Cookie 配置
cookie:
  # 优先从浏览器自动读取
  auto_extract: true
  # 失败时手动填写
  manual: ""

# 下载配置
# download_path: 留空则使用系统 Downloads 目录
# macOS: ~/Downloads/抖音视频下载
# Windows: C:\Users\<用户名>\Downloads\抖音视频下载
download_path: ""
naming_template: "{create}_{desc}_{aweme_id}"

# 增量模式
incremental:
  enabled: true
  # diff: 只下载主页有本地没有的
  # sync: 同步主页（本地删的会重新下）

# Cookie 有效期提醒
cookie_expiry_days: 14

# 视频压缩配置
compression:
  # 是否在下载后自动压缩
  auto_compress: false
  # 压缩质量 (0-51, 越小质量越好, 推荐28-38, 默认32)
  # 数值越大压缩率越高，但质量会下降
  crf: 32
  # 压缩速度预设 (ultrafast~veryslow, 速度越慢压缩率越高)
  preset: "fast"
  # 压缩后是否替换原文件 (默认true，节省空间)
  # 设置为 false 则保留原文件，生成 xxx_compressed.mp4
  replace_original: true
  # 小文件阈值 (字节)，小于此值不压缩 (默认5MB)
  # 原因：小视频压缩后可能变大（编码开销 > 压缩收益）
  skip_small_threshold: 5242880

{
  "说明": "关注列表模板 - 首次运行后会自动更新此文件",
  "users": [
    {
      "uid": "博主ID",
      "sec_user_id": "安全用户ID",
      "name": "博主名称",
      "nickname": "博主昵称",
      "avatar_url": "头像URL",
      "signature": "个人简介",
      "follower_count": 粉丝数,
      "following_count": 关注数,
      "video_count": 作品数,
      "last_updated": "最后更新时间",
      "last_fetch_time": null
    }
  ]
}

Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International

Copyright (c) 2025 杨卫薪律师（微信ywxlaw）

=======================================================================

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.

You are free to:
- Share — copy and redistribute the material in any medium or format
- Adapt — remix, transform, and build upon the material

Under the following terms:
- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.
- NonCommercial — You may not use the material for commercial purposes.
- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license.

No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.

To view a copy of this license, visit:
http://creativecommons.org/licenses/by-nc-sa/4.0/

=======================================================================

Commercial License

For commercial use licenses, please contact:
Email: secretxierluo@gmail.com
WeChat: ywxlaw (微信)

=======================================================================

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
批量下载脚本 - 使用 F2 Python API 下载视频并自动保存统计数据

用法：
    # 交互式选择博主下载
    python scripts/batch-download.py

    # 一键全量下载
    python scripts/batch-download.py --all

    # 下载指定博主
    python scripts/batch-download.py --uid 7483912725043774523

    # 采样下载（每个博主1个视频，用于快速更新统计数据）
    python scripts/batch-download.py --sample

特性：
    - 自动保存视频统计数据（点赞、评论、收藏、分享）
    - 零额外 API 请求（数据在下载时获取）
    - 使用博主昵称作为文件夹名
"""

import subprocess
import sys
import uuid
import time
from pathlib import Path
import os

# 强制使用脚本所在目录作为工作目录
SKILL_DIR = Path(__file__).parent.parent.resolve()
# 切换到脚本目录（确保相对路径正确）
os.chdir(SKILL_DIR)

# 导入统一配置模块
from utils.config import (
    get_download_path,
    get_user_folder_name,
)

from following import (
    list_users,
    get_user,
    update_fetch_time,
)

DOWNLOAD_SCRIPT = SKILL_DIR / "scripts" / "download-v2.py"
DOWNLOADS_PATH = get_download_path()


def get_local_video_count(folder: str) -> int:
    """获取本地视频数量"""
    user_dir = DOWNLOADS_PATH / folder
    if user_dir.exists():
        return len(list(user_dir.glob("*.mp4")))
    return 0


def download_user(uid: str, sec_user_id: str = None, nickname: str = "", max_counts: int = None, daemon: bool = False):
    """下载单个用户的视频

    Args:
        uid: 用户 ID
        sec_user_id: 用户 sec_user_id
        nickname: 用户昵称（用于文件夹命名）
        max_counts: 最大下载数量，None 表示不限制
        daemon: 是否后台运行
    """
    # 构建用户主页 URL
    if sec_user_id and sec_user_id.startswith("MS4w"):
        url = f"https://www.douyin.com/user/{sec_user_id}"
    else:
        url = f"https://www.douyin.com/user/{uid}"

    # 生成任务 ID
    task_id = f"douyin-{uid}-{int(time.time())}"

    if daemon:
        # 后台运行模式
        log_dir = DOWNLOADS_PATH / "logs"
        log_dir.mkdir(parents=True, exist_ok=True)
        log_file = log_dir / f"{task_id}.log"

        cmd = [sys.executable, str(DOWNLOAD_SCRIPT), url, "--daemon", f"--task-id={task_id}"]
        if max_counts is not None:
            cmd.append(f"--max-counts={max_counts}")

        # 使用 nohup 后台运行
        with open(log_file, "w", encoding="utf-8") as f:
            f.write(f"[任务创建] {task_id}\n")
            f.write(f"[UID] {uid}\n")
            f.write(f"[昵称] {nickname}\n")
            f.write(f"[URL] {url}\n")
            f.write(f"[时间] {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write("=" * 60 + "\n")

        # 后台启动进程
        subprocess.Popen(
            cmd,
            cwd=str(SKILL_DIR),
            stdout=open(log_file, "a", encoding="utf-8"),
            stderr=subprocess.STDOUT,
            start_new_session=True,  # 脱离父进程
        )

        print(f"✅ 已启动后台任务: {task_id}")
        print(f"   📋 任务ID: {task_id}")
        print(f"   📁 日志: {log_file}")
        print(f"   🔍 查看进度: tail -f {log_file}")
        return task_id
    else:
        # 同步运行模式
        print(f"\n{'='*60}")
        print(f"📥 开始下载: {nickname or uid}" + (f" (最多 {max_counts} 个)" if max_counts else ""))
        print(f"{'='*60}")

        cmd = [sys.executable, str(DOWNLOAD_SCRIPT), url]
        if max_counts is not None:
            cmd.append(f"--max-counts={max_counts}")

        result = subprocess.run(cmd, cwd=str(SKILL_DIR))

        if result.returncode == 0:
            # 更新 last_fetch_time
            update_fetch_time(uid, nickname)
            print(f"✅ 下载完成: {nickname or uid}")
            return True
        else:
            print(f"❌ 下载失败: {nickname or uid}")
            return False


def interactive_select():
    """交互式选择博主下载"""
    users = list_users()

    if not users:
        print("📋 关注列表为空，请先添加用户")
        print("   用法: python scripts/manage-following.py --batch")
        return

    print("\n📋 选择要下载的博主")
    print("=" * 60)

    for i, user in enumerate(users, 1):
        uid = user.get("uid", "未知")
        name = user.get("nickname", user.get("name", "未知"))
        folder = user.get("folder", name or uid)
        local_count = get_local_video_count(folder)
        last_fetch = user.get("last_fetch_time", "未获取")

        # 显示状态标记
        if local_count > 0:
            status = f"📦 已下载 {local_count} 个"
        else:
            status = "🆕 未下载"

        print(f"  {i:2}. {name}")
        print(f"      UID: {uid}")
        print(f"      文件夹: {folder}")
        print(f"      状态: {status} | 最后获取: {last_fetch or '未获取'}")
        print()

    print("=" * 60)
    print("输入数字选择博主（支持多选，用逗号分隔）")
    print("输入 'all' 下载全部，'q' 退出")
    print("-" * 60)

    choice = input("请选择: ").strip().lower()

    if choice == "q" or choice == "":
        print("❌ 已取消")
        return

    if choice == "all":
        download_all_users(users)
        return

    # 解析选择的数字
    try:
        indices = [int(x.strip()) for x in choice.split(",")]
        selected = []
        for idx in indices:
            if 1 <= idx <= len(users):
                selected.append(users[idx - 1])
            else:
                print(f"⚠️ 无效的序号: {idx}")

        if not selected:
            print("❌ 没有有效的选择")
            return

        print(f"\n📝 已选择 {len(selected)} 个博主")
        download_selected_users(selected)

    except ValueError:
        print("❌ 无效的输入，请输入数字")


def download_selected_users(users: list):
    """下载选定的用户"""
    total = len(users)
    success = 0
    failed = 0

    for i, user in enumerate(users, 1):
        uid = user.get("uid")
        sec_user_id = user.get("sec_user_id", "")
        name = user.get("nickname", user.get("name", "未知"))

        print(f"\n[{i}/{total}] 处理: {name}")

        if download_user(uid, sec_user_id, name):
            success += 1
        else:
            failed += 1

    print("\n" + "=" * 60)
    print(f"✨ 批量下载完成: 成功 {success}，失败 {failed}")
    print(f"📁 下载目录: {DOWNLOADS_PATH}")
    print("=" * 60)


def download_all_users(users: list = None, auto_confirm: bool = False, daemon: bool = False):
    """下载全部用户

    Args:
        users: 用户列表，None 表示从 following.json 加载
        auto_confirm: 是否跳过确认
        daemon: 是否后台运行
    """
    if users is None:
        users = list_users()

    if not users:
        print("📋 关注列表为空，请先添加用户")
        return

    total = len(users)

    if daemon:
        # 后台模式：直接启动所有任务
        print(f"\n🚀 后台模式：准备启动全部 {total} 个下载任务")
        print(f"📁 下载目录: {DOWNLOADS_PATH}")
        print("-" * 60)

        task_ids = []
        for user in users:
            uid = user.get("uid")
            sec_user_id = user.get("sec_user_id", "")
            name = user.get("nickname", user.get("name", "未知"))
            task_id = download_user(uid, sec_user_id, name, daemon=True)
            if task_id:
                task_ids.append((name, task_id))

        print("\n" + "=" * 60)
        print(f"✅ 已启动 {len(task_ids)} 个后台任务")
        print("-" * 60)
        for name, task_id in task_ids:
            print(f"   📺 {name}: {task_id}")
        print("-" * 60)
        print("🔍 查看所有日志: ls {}/logs/")
        print("=" * 60)
    else:
        # 同步模式
        print(f"\n📥 准备下载全部 {total} 个博主")
        print(f"📁 下载目录: {DOWNLOADS_PATH}")
        print("-" * 60)

        if not auto_confirm:
            confirm = input("确认开始？(y/N): ").strip().lower()
            if confirm != "y":
                print("❌ 已取消")
                return

        download_selected_users(users)


def download_by_uid(uid: str, max_counts: int = None, daemon: bool = False):
    """下载指定 UID 的用户

    Args:
        uid: 用户 ID
        max_counts: 最大下载数量
        daemon: 是否后台运行
    """
    user = get_user(uid)

    if not user:
        print(f"❌ 用户 {uid} 不在关注列表中")
        print("   请先添加: python scripts/manage-following.py --add <URL>")
        return

    name = user.get("nickname", user.get("name", "未知"))
    sec_user_id = user.get("sec_user_id", "")

    if daemon:
        print(f"\n🚀 后台模式：准备启动下载任务")
        print(f"   📺 博主: {name} (UID: {uid})")
        print(f"   📁 下载目录: {DOWNLOADS_PATH}")
        print("-" * 60)
        task_id = download_user(uid, sec_user_id, name, max_counts, daemon=True)
        print("\n" + "=" * 60)
        if task_id:
            print(f"✅ 后台任务已启动")
            print(f"   📋 任务ID: {task_id}")
        print("=" * 60)
    else:
        print(f"\n📥 下载博主: {name} (UID: {uid})")
        print(f"📁 下载目录: {DOWNLOADS_PATH}")
        download_user(uid, sec_user_id, name, max_counts)


def download_sample(auto_confirm: bool = False, daemon: bool = False):
    """每个用户只下载1个视频，用于快速更新数据

    Args:
        auto_confirm: 是否跳过确认
        daemon: 是否后台运行
    """
    users = list_users()

    if not users:
        print("📋 关注列表为空，请先添加用户")
        return

    total = len(users)

    if daemon:
        # 后台模式：直接启动所有任务
        print(f"\n🚀 后台模式：准备启动 {total} 个采样下载任务")
        print(f"📁 下载目录: {DOWNLOADS_PATH}")
        print("-" * 60)

        task_ids = []
        for user in users:
            uid = user.get("uid")
            sec_user_id = user.get("sec_user_id", "")
            name = user.get("nickname", user.get("name", "未知"))
            task_id = download_user(uid, sec_user_id, name, max_counts=1, daemon=True)
            if task_id:
                task_ids.append((name, task_id))

        print("\n" + "=" * 60)
        print(f"✅ 已启动 {len(task_ids)} 个后台任务")
        print("-" * 60)
        for name, task_id in task_ids:
            print(f"   📺 {name}: {task_id}")
        print("-" * 60)
        print("🔍 查看所有日志: ls {}/logs/")
        print("=" * 60)
    else:
        # 同步模式
        print(f"\n📥 采样下载：每个博主只下载 1 个视频")
        print(f"   共 {total} 个博主")
        print(f"📁 下载目录: {DOWNLOADS_PATH}")
        print("-" * 60)

        if not auto_confirm:
            confirm = input("确认开始？(y/N): ").strip().lower()
            if confirm != "y":
                print("❌ 已取消")
                return

        success = 0
        failed = 0

        for i, user in enumerate(users, 1):
            uid = user.get("uid")
            sec_user_id = user.get("sec_user_id", "")
            name = user.get("nickname", user.get("name", "未知"))

            print(f"\n[{i}/{total}] 采样下载: {name}")

            if download_user(uid, sec_user_id, name, max_counts=1):
                success += 1
            else:
                failed += 1

        print("\n" + "=" * 60)
    print(f"✨ 采样下载完成: 成功 {success}，失败 {failed}")
    print("=" * 60)


def main():
    # 检查是否有 --yes 参数（跳过确认）
    auto_confirm = "--yes" in sys.argv
    if auto_confirm:
        sys.argv.remove("--yes")

    # 检查是否有 --daemon 参数（后台运行）
    daemon_mode = "--daemon" in sys.argv
    if daemon_mode:
        sys.argv.remove("--daemon")

    if len(sys.argv) < 2:
        interactive_select()
        return

    action = sys.argv[1]

    if action == "--all":
        download_all_users(auto_confirm=auto_confirm, daemon=daemon_mode)
    elif action == "--sample":
        # 每个用户只下载1个视频，用于更新数据
        download_sample(auto_confirm=auto_confirm, daemon=daemon_mode)
    elif action == "--uid":
        if len(sys.argv) < 3:
            print("用法: python scripts/batch-download.py --uid <UID>")
            return
        download_by_uid(sys.argv[2], daemon=daemon_mode)
    else:
        print(f"❌ 未知参数: {action}")
        print("用法:")
        print("  python scripts/batch-download.py           # 交互选择")
        print("  python scripts/batch-download.py --all      # 全量下载")
        print("  python scripts/batch-download.py --sample   # 采样下载（每个1个视频）")
        print("  python scripts/batch-download.py --uid <UID> # 指定博主")
        print("  --daemon                                # 后台运行模式")
        print("  --yes                                   # 跳过确认直接执行")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
环境检测脚本 - 检查 Python 版本和依赖
"""
import sys
import subprocess
import os

def check_python_version():
    """检查 Python 版本"""
    version = sys.version_info
    print(f"当前 Python 版本: {version.major}.{version.minor}.{version.micro}")
    
    # f2 支持 Python 3.9 - 3.13
    if version.major == 3 and version.minor <= 13:
        print("✓ Python 版本兼容 (3.9-3.13)")
        return True
    else:
        print(f"✗ Python 版本不兼容: f2 需要 Python 3.9-3.13，当前是 {version.major}.{version.minor}")
        print("  解决方案: 使用 pyenv 或 conda 安装 Python 3.11")
        return False

def check_f2():
    """检查 f2 是否安装"""
    try:
        result = subprocess.run(['pip', 'show', 'f2'], capture_output=True, text=True)
        if result.returncode == 0:
            for line in result.stdout.split('\n'):
                if line.startswith('Version:'):
                    print(f"✓ f2 已安装: {line.split(':')[1].strip()}")
                    return True
        print("✗ f2 未安装")
        return False
    except Exception as e:
        print(f"✗ 检查 f2 失败: {e}")
        return False

def check_playwright():
    """检查 playwright 是否安装"""
    try:
        result = subprocess.run(['pip', 'show', 'playwright'], capture_output=True, text=True)
        if result.returncode == 0:
            for line in result.stdout.split('\n'):
                if line.startswith('Version:'):
                    print(f"✓ playwright 已安装: {line.split(':')[1].strip()}")
                    return True
        print("✗ playwright 未安装")
        return False
    except Exception as e:
        print(f"✗ 检查 playwright 失败: {e}")
        return False

def main():
    print("=" * 50)
    print("抖音批量下载技能 - 环境检测")
    print("=" * 50)
    
    checks = [
        ("Python 版本", check_python_version()),
        ("f2", check_f2()),
        ("playwright", check_playwright()),
    ]
    
    print("=" * 50)
    print("检测结果:")
    for name, result in checks:
        status = "✓" if result else "✗"
        print(f"  {status} {name}")
    
    if all(r for _, r in checks):
        print("\n✓ 环境检测通过，可以正常使用!")
        return 0
    else:
        print("\n✗ 环境检测未通过，请先配置环境")
        return 1

if __name__ == '__main__':
    sys.exit(main())

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
抖音视频压缩脚本

使用 ffmpeg 对下载的视频进行压缩，支持：
- 单个视频压缩
- 指定用户目录压缩
- 全部下载目录压缩
- 默认直接替换原文件（节省空间）
- 可选保留原文件（使用 --keep）
- 智能跳过小文件（避免压缩后变大）

用法：
    python scripts/compress.py                          # 压缩全部视频
    python scripts/compress.py --user <folder>          # 压缩指定用户视频
    python scripts/compress.py --file <video.mp4>        # 压缩单个文件
    python scripts/compress.py --keep                    # 保留原文件
"""

import subprocess
import sys
import os
from pathlib import Path
import argparse

# 强制使用脚本所在目录作为工作目录
SKILL_DIR = Path(__file__).parent.parent.resolve()
os.chdir(SKILL_DIR)

# 导入统一配置模块
from utils.config import get_download_path

DOWNLOADS_PATH = get_download_path()

# 小文件阈值（字节），小于此值的视频不压缩
# 原因：小视频压缩后可能变大（编码开销 > 压缩收益）
SMALL_FILE_THRESHOLD = 5 * 1024 * 1024  # 5MB

# 低分辨率阈值（高度），低于此值的视频跳过压缩
# 原因：激进模式会降低分辨率，对已低分辨率视频无意义
LOW_RESOLUTION_THRESHOLD = 720  # 720p 高度


def check_ffmpeg():
    """检查 ffmpeg 是否安装"""
    try:
        result = subprocess.run(
            ["ffmpeg", "-version"],
            capture_output=True,
            text=True
        )
        return result.returncode == 0
    except FileNotFoundError:
        return False


def get_video_info(video_path):
    """获取视频信息"""
    try:
        result = subprocess.run([
            "ffprobe", "-v", "quiet",
            "-print_format", "json",
            "-show_format", "-show_streams",
            str(video_path)
        ], capture_output=True, text=True)

        if result.returncode == 0:
            import json
            info = json.loads(result.stdout)
            # 获取文件大小（字节）
            size = int(info["format"]["size"])
            # 获取时长（秒）
            duration = float(info["format"]["duration"])
            # 获取视频分辨率（高度）
            video_stream = next((s for s in info.get("streams", []) if s.get("codec_type") == "video"), None)
            height = int(video_stream.get("height", 0)) if video_stream else 0
            return {"size": size, "duration": duration, "height": height}
    except Exception:
        pass
    return None


def format_size(bytes_size):
    """格式化文件大小"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if bytes_size < 1024.0:
            return f"{bytes_size:.2f} {unit}"
        bytes_size /= 1024.0
    return f"{bytes_size:.2f} TB"


def compress_video(input_path, output_path, replace=True, crf=32, preset="fast", skip_small=True, aggressive=True):
    """
    压缩视频

    参数:
        input_path: 输入视频路径
        output_path: 输出视频路径
        replace: 是否替换原文件 (默认True，节省空间)
        crf: 压缩质量 (0-51, 越小质量越好, 默认32, 推荐28-38)
        preset: 压缩速度预设 (ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow)
        skip_small: 是否跳过小文件 (默认True)
        aggressive: 激进压缩模式 (默认False), 牺牲质量获得更高压缩率
    """
    info = get_video_info(input_path)
    original_size = info["size"] if info else 0
    height = info.get("height", 0) if info else 0

    print(f"  压缩: {input_path.name}")
    print(f"    原始大小: {format_size(original_size)}, 分辨率: {height}p")

    # 跳过小文件（避免压缩后反而变大）
    if skip_small and original_size < SMALL_FILE_THRESHOLD:
        print(f"    跳过 (文件小于 {format_size(SMALL_FILE_THRESHOLD)})")
        return None  # 返回 None 表示跳过

    # 跳过低分辨率视频（避免对已低分辨率视频进行压缩）
    if aggressive and height > 0 and height < LOW_RESOLUTION_THRESHOLD:
        print(f"    跳过 (分辨率 {height}p 已低于阈值 {LOW_RESOLUTION_THRESHOLD}p)")
        return None  # 返回 None 表示跳过

    # ffmpeg 命令
    if aggressive:
        # 激进模式：降低分辨率 + 降低音频码率
        cmd = [
            "ffmpeg", "-i", str(input_path),
            "-c:v", "libx264",
            "-crf", str(crf),
            "-preset", preset,
            "-vf", "scale=iw/2:ih/2",  # 降低分辨率到一半
            "-c:a", "aac",
            "-b:a", "64k",  # 降低音频码率
            "-movflags", "+faststart",
            "-y",
            str(output_path)
        ]
    else:
        # 标准模式
        cmd = [
            "ffmpeg", "-i", str(input_path),
            "-c:v", "libx264",
            "-crf", str(crf),
            "-preset", preset,
            "-c:a", "aac",
            "-b:a", "128k",
            "-movflags", "+faststart",
            "-y",
            str(output_path)
        ]

    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        print(f"    ✗ 压缩失败: {result.stderr}")
        return False

    # 获取压缩后大小
    compressed_info = get_video_info(output_path)
    compressed_size = compressed_info["size"] if compressed_info else 0

    # 计算压缩率
    if original_size > 0 and compressed_size > 0:
        ratio = (1 - compressed_size / original_size) * 100
        print(f"    压缩后: {format_size(compressed_size)} (压缩率: {ratio:.1f}%)")

    # 如果需要替换原文件
    if replace:
        input_path.unlink()
        output_path.rename(input_path)
        print(f"    已替换原文件")
    else:
        print(f"    输出: {output_path}")

    return True


def is_already_compressed(video_path):
    """检查视频是否已经是压缩版"""
    # 简单判断：文件名包含 compressed 或 compressed_ 前缀
    return "compressed" in video_path.stem.lower()


def compress_user_dir(user_dir, replace=True, skip_small=True, **kwargs):
    """压缩指定用户目录下的所有视频"""
    if not user_dir.exists():
        print(f"目录不存在: {user_dir}")
        return

    mp4_files = list(user_dir.glob("*.mp4"))
    if not mp4_files:
        print(f"没有找到视频文件: {user_dir}")
        return

    print(f"\n处理用户目录: {user_dir.name}")
    print(f"找到 {len(mp4_files)} 个视频文件\n")

    success_count = 0
    skipped_count = 0
    failed_count = 0

    for video in mp4_files:
        # 跳过已经是压缩版的文件
        if is_already_compressed(video):
            print(f"  跳过 (已压缩): {video.name}")
            skipped_count += 1
            print()
            continue

        if replace:
            output = video.parent / f"{video.stem}.tmp.mp4"
        else:
            output = video.parent / f"{video.stem}_compressed.mp4"

        result = compress_video(video, output, replace, skip_small=skip_small, **kwargs)
        if result is True:
            success_count += 1
        elif result is False:
            failed_count += 1
        else:  # None - 跳过
            skipped_count += 1

        print()

    print(f"完成: {success_count} 成功, {skipped_count} 跳过, {failed_count} 失败")


def compress_all(replace=True, skip_small=True, **kwargs):
    """压缩下载目录下所有用户的视频"""
    if not DOWNLOADS_PATH.exists():
        print(f"下载目录不存在: {DOWNLOADS_PATH}")
        return

    user_dirs = [d for d in DOWNLOADS_PATH.iterdir() if d.is_dir()]
    if not user_dirs:
        print("没有找到用户目录")
        return

    print(f"下载目录: {DOWNLOADS_PATH}")
    print(f"找到 {len(user_dirs)} 个用户目录\n")

    for user_dir in sorted(user_dirs):
        compress_user_dir(user_dir, replace, skip_small, **kwargs)


def main():
    parser = argparse.ArgumentParser(
        description="抖音视频压缩脚本",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  %(prog)s                          # 压缩全部视频（默认直接替换原文件）
  %(prog)s --user 博主昵称           # 压缩指定用户视频
  %(prog)s --file video.mp4           # 压缩单个文件
  %(prog)s --keep                    # 保留原文件（生成 xxx_compressed.mp4）
  %(prog)s --aggressive               # 激进压缩模式 (牺牲质量，压缩率70-80%%)
  %(prog)s --crf 38 --preset medium   # 指定压缩质量和速度
  %(prog)s --no-skip-small            # 不跳过小文件
        """
    )

    parser.add_argument(
        "--user", "-u",
        help="指定用户文件夹名称（博主昵称），只压缩该用户的视频"
    )
    parser.add_argument(
        "--file", "-f",
        help="压缩单个视频文件"
    )
    parser.add_argument(
        "--keep", "-k",
        action="store_true",
        help="保留原文件（默认压缩后直接替换，节省空间）"
    )
    parser.add_argument(
        "--crf",
        type=int,
        default=32,
        help="视频压缩质量 (0-51, 默认32). 数值越小质量越好，文件越大. 推荐28-38"
    )
    parser.add_argument(
        "--no-skip-small",
        action="store_true",
        help="不跳过小文件 (默认跳过小于5MB的文件)"
    )
    parser.add_argument(
        "--preset",
        default="fast",
        choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
        help="压缩速度预设 (默认: fast). 速度越慢压缩率越高"
    )
    parser.add_argument(
        "--aggressive", "-a",
        action="store_true",
        help="激进压缩模式 (牺牲质量获得更高压缩率，适合视频仅作留存用途)"
    )

    args = parser.parse_args()

    # 是否跳过小文件
    skip_small = not args.no_skip_small
    # 是否保留原文件（默认替换）
    replace = not args.keep

    # 检查 ffmpeg
    if not check_ffmpeg():
        print("错误: 未找到 ffmpeg")
        print("请先安装 ffmpeg:")
        print("  macOS:   brew install ffmpeg")
        print("  Ubuntu:  sudo apt install ffmpeg")
        print("  Windows: choco install ffmpeg")
        sys.exit(1)

    print(f"下载目录: {DOWNLOADS_PATH}")

    # 执行压缩
    if args.file:
        # 压缩单个文件
        file_path = Path(args.file)
        if not file_path.is_absolute():
            file_path = DOWNLOADS_PATH / file_path

        if not file_path.exists():
            print(f"文件不存在: {file_path}")
            sys.exit(1)

        if replace:
            output = file_path.parent / f"{file_path.stem}.tmp.mp4"
        else:
            output = file_path.parent / f"{file_path.stem}_compressed.mp4"

        compress_video(file_path, output, replace, args.crf, args.preset, skip_small, args.aggressive)

    elif args.user:
        # 压缩指定用户目录
        user_dir = DOWNLOADS_PATH / args.user
        compress_user_dir(user_dir, replace, skip_small, crf=args.crf, preset=args.preset, aggressive=args.aggressive)

    else:
        # 压缩全部
        compress_all(replace, skip_small, crf=args.crf, preset=args.preset, aggressive=args.aggressive)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
抖音视频下载脚本 v2 - 使用 F2 Python API，同时保存视频统计数据

工作流程：
1. 使用 F2 Python API 下载视频（自动跳过已存在文件）
2. 在下载过程中保存视频统计数据（点赞、评论、收藏等）到数据库
3. 自动整理文件到下载目录/{博主昵称}/
4. 同步 following.json

用法：
    python scripts/download-v2.py <主页URL>
    python scripts/download-v2.py <主页URL> --max-counts=10

优势：
- 不增加额外 API 请求（数据在下载时已获取）
- 自动保存视频统计数据到数据库
- 使用博主昵称作为文件夹名（更易识别）
"""

import shutil
import sqlite3
import asyncio
import sys
import yaml
import os
import re
from pathlib import Path
from datetime import datetime
from typing import Dict, List

# 强制使用脚本所在目录作为工作目录
SKILL_DIR = Path(__file__).parent.parent.resolve()
os.chdir(SKILL_DIR)

# 导入统一配置模块
from utils.config import (
    get_download_path,
    get_db_path,
    get_user_folder_name,
    sanitize_folder_name,
    load_config,
)

# 导入 F2 模块
from f2.apps.douyin.handler import DouyinHandler
from f2.apps.douyin.db import AsyncUserDB, AsyncVideoDB
from f2.utils.conf_manager import ConfigManager
import f2


def merge_config(main_conf: dict, custom_conf: dict) -> dict:
    """合并配置"""
    result = (main_conf or {}).copy()
    for key, value in (custom_conf or {}).items():
        if isinstance(value, dict) and key in result and isinstance(result[key], dict):
            result[key].update(value)
        else:
            result[key] = value
    return result


def get_f2_kwargs() -> dict:
    """获取 F2 所需的配置参数"""
    # 加载 F2 默认配置
    try:
        main_conf_manager = ConfigManager(f2.F2_CONFIG_FILE_PATH)
        all_conf = main_conf_manager.config  # 获取完整配置
        main_conf = all_conf.get("douyin", {}) if all_conf else {}
    except Exception:
        main_conf = {}

    # 加载自定义配置
    custom_conf = load_config()
    douyin_custom = custom_conf.get("douyin", custom_conf)  # 兼容两种格式

    # 合并配置
    kwargs = merge_config(main_conf, douyin_custom)

    # 添加必要参数
    kwargs["app_name"] = "douyin"
    kwargs["mode"] = "post"

    # 设置路径 - 使用统一配置模块
    kwargs["path"] = str(get_download_path())

    # 确保 cookie 存在
    if not kwargs.get("cookie"):
        raise ValueError("未配置 cookie，请在 config/config.yaml 中设置")

    # 确保 headers 存在（F2 需要这个）
    if not kwargs.get("headers"):
        kwargs["headers"] = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": "https://www.douyin.com/",
        }

    return kwargs


def create_video_metadata_table():
    """确保视频元数据表存在"""
    db_path = get_db_path()
    conn = sqlite3.connect(str(db_path))
    cursor = conn.cursor()

    cursor.execute("""
        CREATE TABLE IF NOT EXISTS video_metadata (
            aweme_id TEXT PRIMARY KEY,
            uid TEXT NOT NULL,
            nickname TEXT,
            desc TEXT,
            create_time INTEGER,
            duration INTEGER,
            digg_count INTEGER DEFAULT 0,
            comment_count INTEGER DEFAULT 0,
            collect_count INTEGER DEFAULT 0,
            share_count INTEGER DEFAULT 0,
            play_count INTEGER DEFAULT 0,
            local_filename TEXT,
            file_size INTEGER,
            fetch_time INTEGER
        )
    """)

    cursor.execute("""
        CREATE INDEX IF NOT EXISTS idx_video_uid ON video_metadata(uid)
    """)

    # 添加 nickname 列（如果不存在）
    try:
        cursor.execute("ALTER TABLE video_metadata ADD COLUMN nickname TEXT")
    except sqlite3.OperationalError:
        pass  # 列已存在

    conn.commit()
    conn.close()


def save_video_metadata_from_raw(raw_data: dict, nickname: str = ""):
    """从原始 API 响应中提取并保存视频统计数据"""
    aweme_list = raw_data.get("aweme_list", [])
    if not aweme_list:
        return 0

    db_path = get_db_path()
    conn = sqlite3.connect(str(db_path))
    cursor = conn.cursor()

    fetch_time = int(datetime.now().timestamp())
    saved_count = 0

    for video in aweme_list:
        aweme_id = video.get("aweme_id", "")
        if not aweme_id:
            continue

        # 从原始数据中获取统计信息
        stats = video.get("statistics", {}) or {}
        author = video.get("author", {}) or {}
        video_nickname = author.get("nickname", nickname)

        cursor.execute("""
            INSERT OR REPLACE INTO video_metadata
            (aweme_id, uid, nickname, desc, create_time, duration,
             digg_count, comment_count, collect_count, share_count, play_count,
             fetch_time)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            aweme_id,
            author.get("uid", ""),
            video_nickname,
            video.get("desc", ""),
            video.get("create_time", 0),
            video.get("video", {}).get("duration", 0) if video.get("video") else 0,
            stats.get("digg_count", 0),
            stats.get("comment_count", 0),
            stats.get("collect_count", 0),
            stats.get("share_count", 0),
            stats.get("play_count", 0),
            fetch_time
        ))
        saved_count += 1

    conn.commit()
    conn.close()
    return saved_count


def reorganize_files(nickname: str, uid: str) -> str:
    """整理文件到下载目录/{博主昵称}/"""
    downloads_path = get_download_path()
    old_path = downloads_path / "douyin" / "post" / nickname

    if not old_path.exists():
        return None

    # 使用博主昵称作为文件夹名
    folder_name = get_user_folder_name(nickname, uid)
    new_path = downloads_path / folder_name
    new_path.mkdir(parents=True, exist_ok=True)

    # 移动文件
    moved_count = 0
    for pattern in ["*.mp4", "*.jpg", "*.webp"]:
        for f in old_path.glob(pattern):
            dest = new_path / f.name
            if not dest.exists():
                shutil.move(str(f), str(dest))
                moved_count += 1

    # 清理旧文件夹
    if old_path.exists():
        try:
            shutil.rmtree(old_path)
        except:
            pass

    if moved_count > 0:
        print(f"  [移动] {nickname} -> {folder_name} ({moved_count} 文件)")

    return folder_name


def update_last_fetch_time(uid: str, nickname: str = ""):
    """更新 following.json 中的 last_fetch_time"""
    try:
        from following import update_fetch_time
        update_fetch_time(uid, nickname)
        print(f"  [更新] last_fetch_time for {nickname or uid}")
    except ImportError:
        pass


def run_sync():
    """运行 sync-following.py"""
    import subprocess
    subprocess.run([sys.executable, str(SKILL_DIR / "scripts" / "sync-following.py")])


async def download_with_stats(url: str, max_counts: int = None):
    """
    使用 F2 API 下载视频并保存统计数据

    Args:
        url: 用户主页 URL
        max_counts: 最大下载数量
    """
    # 获取配置
    kwargs = get_f2_kwargs()
    kwargs["url"] = url

    if max_counts:
        kwargs["max_counts"] = max_counts

    downloads_path = get_download_path()

    # 清理临时目录
    f2_temp_path = downloads_path / "douyin"
    if f2_temp_path.exists():
        shutil.rmtree(f2_temp_path)
        print("[清理] F2 临时目录")

    print(f"[下载] 开始下载...")
    print(f"[路径] {downloads_path}")

    # 创建元数据表
    create_video_metadata_table()

    # 初始化 Handler
    handler = DouyinHandler(kwargs)

    # 解析 sec_user_id
    from f2.apps.douyin.utils import SecUserIdFetcher
    sec_user_id = await SecUserIdFetcher.get_sec_user_id(url)

    if not sec_user_id:
        print("[错误] 无法解析用户 ID")
        return

    print(f"[信息] sec_user_id: {sec_user_id[:30]}...")

    # 获取用户信息并保存
    async with AsyncUserDB(str(get_db_path())) as db:
        user_path = await handler.get_or_add_user_data(kwargs, sec_user_id, db)

    # 从数据库获取用户信息（昵称）
    conn = sqlite3.connect(str(get_db_path()))
    cursor = conn.cursor()
    cursor.execute("SELECT uid, nickname FROM user_info_web ORDER BY ROWID DESC LIMIT 1")
    user_info = cursor.fetchone()
    conn.close()

    uid = user_info[0] if user_info else ""
    nickname = user_info[1] if user_info else ""

    if nickname:
        print(f"[博主] {nickname} (UID: {uid})")

    # 收集所有视频数据
    all_videos = []
    total_downloaded = 0
    total_stats_saved = 0

    print("[下载] 正在获取视频列表...")

    async for aweme_data_list in handler.fetch_user_post_videos(
        sec_user_id,
        max_counts=max_counts or float("inf")
    ):
        # 获取视频数据列表（用于下载）
        video_list = aweme_data_list._to_list()

        if video_list:
            all_videos.extend(video_list)

            # 从原始数据中保存统计数据（不增加额外请求）
            raw_data = aweme_data_list._to_raw()
            stats_saved = save_video_metadata_from_raw(raw_data, nickname)
            total_stats_saved += stats_saved

            # 创建下载任务
            await handler.downloader.create_download_tasks(
                kwargs, video_list, user_path
            )

            total_downloaded += len(video_list)
            print(f"[下载] 已处理 {total_downloaded} 个视频...")

    # 显示统计结果
    print(f"[统计] 保存了 {total_stats_saved} 条视频元数据（含点赞/评论等数据）")

    # 整理文件
    print("[整理] 重新组织文件...")
    post_path = downloads_path / "douyin" / "post"
    folder_name = None
    if post_path.exists():
        for folder in post_path.iterdir():
            if folder.is_dir():
                folder_name = reorganize_files(folder.name, uid)

    # 更新 last_fetch_time
    if folder_name:
        update_last_fetch_time(uid, nickname or folder_name)

    # 同步 following.json
    print("[同步] 更新 following.json...")
    run_sync()

    print(f"\n[完成] 共下载 {total_downloaded} 个视频")
    if folder_name:
        print(f"[位置] {downloads_path / folder_name}")


async def main():
    # 检查是否需要作为守护进程运行（由 batch-download.py 调用）
    daemon_mode = "--daemon" in sys.argv
    if daemon_mode:
        sys.argv.remove("--daemon")

    if len(sys.argv) < 2:
        print("用法: python scripts/download-v2.py <主页URL>")
        print("  示例: python scripts/download-v2.py https://www.douyin.com/user/xxx")
        print("  限制数量: python scripts/download-v2.py <URL> --max-counts=10")
        print("  后台运行: python scripts/download-v2.py <URL> --daemon")
        return

    url = sys.argv[1]

    # 解析参数
    max_counts = None
    task_id = None  # 任务 ID（守护模式使用）

    for arg in sys.argv[2:]:
        if arg.startswith("--max-counts="):
            max_counts = int(arg.split("=")[1])
        elif arg.startswith("--task-id="):
            task_id = arg.split("=")[1]

    # 守护进程模式：立即输出进度信息后开始下载
    if daemon_mode and task_id:
        downloads_path = get_download_path()
        log_file = downloads_path / "logs" / f"{task_id}.log"
        log_file.parent.mkdir(parents=True, exist_ok=True)

        # 打开日志文件并保持打开状态
        log_handle = open(log_file, "w", encoding="utf-8")
        log_handle.write(f"[任务启动] {task_id}\n")
        log_handle.write(f"[URL] {url}\n")
        log_handle.write(f"[时间] {datetime.now().isoformat()}\n")
        log_handle.write("=" * 60 + "\n")
        log_handle.flush()

        # 重定向 stdout/stderr 到日志文件
        sys.stdout = log_handle
        sys.stderr = log_handle

        print(f"[守护模式] 任务 {task_id} 已启动")
        print(f"[日志] {log_file}")

    await download_with_stats(url, max_counts)

    # 守护进程模式：关闭日志文件
    if daemon_mode and task_id:
        log_handle.close()


if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
抖音视频下载脚本（已废弃）

⚠️ DEPRECATED: 此脚本已被 download-v2.py 取代
推荐使用: python scripts/download-v2.py <主页URL>

download-v2.py 优势：
- 使用 F2 Python API，更稳定
- 自动保存视频统计数据（点赞、评论、收藏、分享）
- 零额外 API 请求

---

工作流程：
1. 使用 F2 CLI 下载视频（自动跳过已存在文件）
2. 自动整理文件到 downloads/{uid}/
3. 运行 sync-following.py 更新 following.json（含 last_fetch_time）

用法：
    python scripts/download.py <主页URL>           # 首次下载（全量）
    python scripts/download.py <主页URL> --incr    # 增量下载（只下新视频）

增量抓取说明：
- following.json 记录每个用户的 last_fetch_time
- 下载时通过文件存在性检测自动跳过已有视频
- 下载完成后更新 last_fetch_time
"""

import subprocess
import shutil
import sqlite3
import asyncio
import sys
from pathlib import Path
import os

# 强制使用脚本所在目录作为工作目录
SKILL_DIR = Path(__file__).parent.parent.resolve()
# 切换到脚本目录（确保相对路径正确）
os.chdir(SKILL_DIR)

CONFIG_PATH = SKILL_DIR / "config" / "config.yaml"
DB_PATH = SKILL_DIR / "douyin_users.db"
DOWNLOADS_PATH = SKILL_DIR / "downloads"


def get_uid_from_db():
    """从 F2 数据库获取最新的 uid"""
    try:
        conn = sqlite3.connect(str(DB_PATH))
        cursor = conn.cursor()
        cursor.execute("SELECT uid, nickname FROM user_info_web ORDER BY ROWID DESC LIMIT 1")
        result = cursor.fetchone()
        conn.close()
        return result
    except Exception:
        return None


def reorganize_files(nickname):
    """整理文件到 downloads/{uid}/"""
    old_path = DOWNLOADS_PATH / "douyin" / "post" / nickname

    if not old_path.exists():
        return None

    # 获取 uid
    uid_info = get_uid_from_db()
    if not uid_info:
        return None

    uid, _ = uid_info
    new_path = DOWNLOADS_PATH / str(uid)

    # 确保目标文件夹存在
    new_path.mkdir(parents=True, exist_ok=True)

    # 移动所有 mp4 文件（即使已存在也检查是否需要补充）
    moved_count = 0
    for f in old_path.glob("*.mp4"):
        dest = new_path / f.name
        if not dest.exists():
            shutil.move(str(f), str(dest))
            moved_count += 1

    # 如果旧文件夹还有图片也一起移动
    for f in old_path.glob("*.jpg"):
        dest = new_path / f.name
        if not dest.exists():
            shutil.move(str(f), str(dest))
            moved_count += 1

    # 删除旧文件夹（如果为空或不再需要）
    if old_path.exists():
        try:
            shutil.rmtree(old_path)
            print(f"  [清理] {nickname} -> 已删除旧文件夹")
        except:
            pass

    if moved_count > 0:
        print(f"  [移动] {nickname} -> {uid} ({moved_count} 文件)")

    return uid


def run_sync():
    """运行 sync-following.py"""
    subprocess.run([sys.executable, str(SKILL_DIR / "scripts" / "sync-following.py")])


def update_last_fetch_time(uid):
    """更新 following.json 中的 last_fetch_time"""
    from following import update_fetch_time
    update_fetch_time(uid)
    print(f"  [更新] last_fetch_time for {uid}")



async def main():
    # 弃用警告
    print("=" * 60)
    print("⚠️  警告: 此脚本已被废弃，推荐使用 download-v2.py")
    print("   新版优势: 自动保存视频统计数据（点赞、评论等）")
    print("   用法: python scripts/download-v2.py <主页URL>")
    print("=" * 60)
    print()

    if len(sys.argv) < 2:
        print("用法: python scripts/download.py <主页URL>")
        print("  示例: python scripts/download.py https://www.douyin.com/user/xxx")
        return

    url = sys.argv[1]

    # 解析可选参数
    max_counts = None
    extra_args = []
    for arg in sys.argv[2:]:
        if arg.startswith("--max-counts="):
            max_counts = int(arg.split("=")[1])
        else:
            extra_args.append(arg)

    print("开始下载...")

    # 0. 清理 F2 临时结构
    f2_temp_path = DOWNLOADS_PATH / "douyin"
    if f2_temp_path.exists():
        shutil.rmtree(f2_temp_path)
        print("\n0. 清理 F2 临时目录...")

    # 1. 运行 F2 CLI（设置工作目录环境变量，确保日志路径正确）
    print("\n1. 下载中...")

    # 设置 F2 工作目录为技能目录
    f2_env = os.environ.copy()
    f2_env["PWD"] = str(SKILL_DIR)

    # 构建 F2 命令
    f2_cmd = [
        "f2", "dy",
        "-c", str(CONFIG_PATH),
        "-u", url,
        "-M", "post"
    ]
    if max_counts is not None:
        f2_cmd.extend(["--max-counts", str(max_counts)])

    result = subprocess.run(f2_cmd, env=f2_env, capture_output=True, text=True)

    if result.returncode != 0:
        print(f"F2 下载失败: {result.stderr}")
        return

    # 2. 整理文件
    print("\n2. 整理文件...")

    # 查找刚下载的昵称文件夹
    post_path = DOWNLOADS_PATH / "douyin" / "post"
    uid = None
    if post_path.exists():
        for folder in post_path.iterdir():
            if folder.is_dir():
                uid = reorganize_files(folder.name)

    # 3. 更新 last_fetch_time
    if uid:
        update_last_fetch_time(uid)

    # 4. 同步 following.json
    print("\n3. 同步 following.json...")
    run_sync()

    # 5. 提取视频元数据（点赞、评论、收藏等统计信息）
    print("\n4. 提取视频元数据...")
    subprocess.run([sys.executable, str(SKILL_DIR / "scripts" / "extract-metadata.py")])

    # 6. 生成 Web 数据文件
    print("\n5. 生成数据文件...")
    subprocess.run([sys.executable, str(SKILL_DIR / "scripts" / "generate-data.py")])

    print("\n完成！")


if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
视频元数据提取脚本

从本地视频文件和 F2 数据库提取视频元数据并保存到 SQLite 数据库。

用法：
    python scripts/extract-metadata.py              # 扫描本地视频并提取元数据
    python scripts/extract-metadata.py --stats      # 显示统计摘要

⚠️ DEPRECATED: --fetch 选项已废弃
推荐使用 download-v2.py 重新下载视频，会自动保存统计数据：
    python scripts/download-v2.py <主页URL>

原因：
- --fetch 使用浏览器方式获取数据，可能触发反爬
- download-v2.py 在下载时自动保存统计数据，零额外请求
"""

import argparse
import asyncio
import os
import re
import sqlite3
import time
from datetime import datetime
from pathlib import Path
from typing import Dict, List

# 强制使用脚本所在目录作为工作目录
SKILL_DIR = Path(__file__).parent.parent.resolve()
os.chdir(SKILL_DIR)

DB_PATH = SKILL_DIR / "douyin_users.db"
F2_VIDEO_DB_PATH = SKILL_DIR / "douyin_videos.db"
CONFIG_PATH = SKILL_DIR / "config" / "config.yaml"


def create_metadata_table():
    """创建视频元数据表"""
    conn = sqlite3.connect(str(DB_PATH))
    cursor = conn.cursor()

    cursor.execute("""
        CREATE TABLE IF NOT EXISTS video_metadata (
            aweme_id TEXT PRIMARY KEY,
            uid TEXT NOT NULL,
            desc TEXT,
            create_time INTEGER,
            duration INTEGER,
            digg_count INTEGER DEFAULT 0,
            comment_count INTEGER DEFAULT 0,
            collect_count INTEGER DEFAULT 0,
            share_count INTEGER DEFAULT 0,
            play_count INTEGER DEFAULT 0,
            local_filename TEXT,
            file_size INTEGER,
            fetch_time INTEGER
        )
    """)

    cursor.execute("""
        CREATE INDEX IF NOT EXISTS idx_video_uid ON video_metadata(uid)
    """)

    cursor.execute("""
        CREATE INDEX IF NOT EXISTS idx_video_digg ON video_metadata(digg_count DESC)
    """)

    conn.commit()
    conn.close()
    print("✅ 元数据表已创建/验证")


def get_video_stats_from_f2_db() -> List[Dict]:
    """从 F2 的视频数据库获取统计数据（如果存在）"""
    if not F2_VIDEO_DB_PATH.exists():
        return []

    conn = sqlite3.connect(str(F2_VIDEO_DB_PATH))
    cursor = conn.cursor()

    try:
        cursor.execute("""
            SELECT
                aweme_id, uid, desc, create_time, duration,
                digg_count, comment_count, collect_count, share_count
            FROM video_info
        """)
        rows = cursor.fetchall()
        conn.close()

        videos = []
        for row in rows:
            videos.append({
                "aweme_id": row[0],
                "uid": row[1] or "",
                "desc": row[2] or "",
                "create_time": int(row[3]) if row[3] else 0,
                "duration": int(row[4]) if row[4] else 0,
                "digg_count": int(row[5]) if row[5] else 0,
                "comment_count": int(row[6]) if row[6] else 0,
                "collect_count": int(row[7]) if row[7] else 0,
                "share_count": int(row[8]) if row[8] else 0,
            })
        return videos
    except sqlite3.OperationalError:
        conn.close()
        return []


def scan_local_videos() -> Dict[str, Dict]:
    """扫描本地视频文件，返回 aweme_id -> 文件信息的映射"""
    downloads_path = SKILL_DIR / "downloads"
    if not downloads_path.exists():
        return {}

    videos = {}
    for video_file in downloads_path.rglob("*.mp4"):
        # 文件名格式: {时间戳}_{描述}_{aweme_id}_video.mp4
        # 注意：描述中可能包含下划线
        stem = video_file.stem

        # 移除末尾的 _video
        stem = re.sub(r'_video$', '', stem)

        # 找所有纯数字段
        parts = stem.split("_")
        numeric_parts = []
        for part in parts:
            part = part.strip()
            if part.isdigit() and len(part) >= 15:
                numeric_parts.append(part)

        # 如果找到纯数字段，返回最长的那个
        if numeric_parts:
            aweme_id = max(numeric_parts, key=len)
        else:
            # 回退方案：使用正则表达式找最长的数字串
            matches = re.findall(r'\d{15,}', stem)
            if matches:
                aweme_id = max(matches, key=len)
            else:
                continue

        stat = video_file.stat()
        parent_dir = video_file.parent.name  # uid

        videos[aweme_id] = {
            "aweme_id": aweme_id,
            "uid": parent_dir,
            "local_filename": video_file.name,
            "file_size": stat.st_size,
        }

    return videos


def save_metadata(videos: List[Dict]):
    """保存元数据到数据库"""
    if not videos:
        print("⚠️ 没有视频元数据需要保存")
        return

    conn = sqlite3.connect(str(DB_PATH))
    cursor = conn.cursor()

    fetch_time = int(datetime.now().timestamp())

    for video in videos:
        cursor.execute("""
            INSERT OR REPLACE INTO video_metadata
            (aweme_id, uid, desc, create_time, duration,
             digg_count, comment_count, collect_count, share_count, play_count,
             local_filename, file_size, fetch_time)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            video.get("aweme_id"),
            video.get("uid", ""),
            video.get("desc", ""),
            video.get("create_time", 0),
            video.get("duration", 0),
            video.get("digg_count", 0),
            video.get("comment_count", 0),
            video.get("collect_count", 0),
            video.get("share_count", 0),
            video.get("play_count", 0),
            video.get("local_filename", ""),
            video.get("file_size", 0),
            fetch_time
        ))

    conn.commit()
    conn.close()
    print(f"✅ 已保存 {len(videos)} 条视频元数据")


def get_cookie_from_config() -> str:
    """从配置文件读取 Cookie"""
    import yaml

    if CONFIG_PATH.exists():
        with open(CONFIG_PATH, "r", encoding="utf-8") as f:
            config = yaml.safe_load(f)
            return config.get("douyin", {}).get("cookie", "") or config.get("cookie", "")
    return ""


def get_sec_user_id_from_db(uid: str) -> str:
    """从数据库获取 sec_user_id"""
    try:
        conn = sqlite3.connect(str(DB_PATH))
        cursor = conn.cursor()
        cursor.execute("SELECT sec_user_id FROM user_info_web WHERE uid = ?", (uid,))
        result = cursor.fetchone()
        conn.close()
        return result[0] if result else ""
    except Exception:
        return ""


async def fetch_video_stats_from_user_page(sec_user_id: str, delay: float = 2.0) -> Dict[str, Dict]:
    """
    通过访问用户主页获取视频统计数据

    从 API 响应中捕获 aweme_list 数据

    Args:
        sec_user_id: 用户的 sec_user_id
        delay: 请求延迟

    Returns:
        aweme_id -> 统计数据的字典
    """
    try:
        from playwright.async_api import async_playwright
    except ImportError:
        print("❌ 需要安装 playwright: pip install playwright && playwright install chromium")
        return {}

    stats_data = {}
    all_videos = []

    print("  启动浏览器...")

    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
        )

        # 加载 Cookie
        cookie_str = get_cookie_from_config()
        if cookie_str:
            cookies = []
            for item in cookie_str.split(';'):
                item = item.strip()
                if '=' in item:
                    name, value = item.split('=', 1)
                    cookies.append({
                        "name": name.strip(),
                        "value": value.strip(),
                        "domain": ".douyin.com",
                        "path": "/"
                    })
            if cookies:
                await context.add_cookies(cookies)
                print(f"  已加载 {len(cookies)} 个 Cookie")

        # 监听 API 响应
        async def handle_response(response):
            if 'aweme/post' in response.url:
                try:
                    data = await response.json()
                    aweme_list = data.get('aweme_list', [])
                    for v in aweme_list:
                        aweme_id = v.get('aweme_id', '')
                        stats = v.get('statistics', {})
                        if aweme_id:
                            all_videos.append({
                                "aweme_id": aweme_id,
                                "uid": v.get('author', {}).get('uid', ''),
                                "desc": v.get('desc', ''),
                                "create_time": v.get('create_time', 0),
                                "duration": v.get('duration', 0),
                                "digg_count": stats.get('digg_count', 0),
                                "comment_count": stats.get('comment_count', 0),
                                "collect_count": stats.get('collect_count', 0),
                                "share_count": stats.get('share_count', 0),
                                "play_count": stats.get('play_count', 0),
                            })
                except Exception:
                    pass

        page = await context.new_page()
        page.on('response', handle_response)

        url = f"https://www.douyin.com/user/{sec_user_id}"
        print(f"  访问用户主页...")

        try:
            await page.goto(url, wait_until="domcontentloaded", timeout=60000)
            print("  页面加载完成，等待 API 响应...")

            # 滚动页面以加载更多视频
            for i in range(5):
                await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
                await page.wait_for_timeout(2000)
                print(f"  滚动加载中... ({i+1}/5)")

            # 再等待一下确保所有请求完成
            await page.wait_for_timeout(3000)

        except Exception as e:
            print(f"  访问页面时出错: {e}")

        await browser.close()

    # 整理数据
    for v in all_videos:
        stats_data[v['aweme_id']] = v

    print(f"  ✅ 获取到 {len(stats_data)} 个视频的统计数据")
    return stats_data


def get_stats_summary() -> Dict:
    """获取统计摘要"""
    conn = sqlite3.connect(str(DB_PATH))
    cursor = conn.cursor()

    # 视频总数
    cursor.execute("SELECT COUNT(*) FROM video_metadata")
    total_videos = cursor.fetchone()[0]

    # 有统计数据的视频数
    cursor.execute("SELECT COUNT(*) FROM video_metadata WHERE digg_count > 0")
    videos_with_stats = cursor.fetchone()[0]

    # 总点赞数
    cursor.execute("SELECT SUM(digg_count) FROM video_metadata")
    total_diggs = cursor.fetchone()[0] or 0

    # 用户统计
    cursor.execute("""
        SELECT uid, COUNT(*) as count, SUM(digg_count) as total_diggs
        FROM video_metadata
        GROUP BY uid
        ORDER BY total_diggs DESC
    """)
    user_stats = cursor.fetchall()

    conn.close()

    return {
        "total_videos": total_videos,
        "videos_with_stats": videos_with_stats,
        "total_diggs": total_diggs,
        "user_stats": user_stats
    }


def main():
    parser = argparse.ArgumentParser(description="视频元数据提取工具")
    parser.add_argument("--fetch", action="store_true", help="从网页获取统计数据（需要 sec_user_id）")
    parser.add_argument("--stats", action="store_true", help="显示统计摘要")
    parser.add_argument("--uid", type=str, help="指定用户 UID")
    args = parser.parse_args()

    print("=" * 50)
    print("视频元数据提取工具")
    print("=" * 50)

    # 创建表
    create_metadata_table()

    if args.stats:
        # 显示统计
        stats = get_stats_summary()
        print(f"\n📊 统计摘要:")
        print(f"   总视频数: {stats['total_videos']}")
        print(f"   有统计数据的视频: {stats['videos_with_stats']}")
        print(f"   总点赞数: {stats['total_diggs']:,}")
        print(f"\n   用户统计:")
        for uid, count, diggs in stats['user_stats'][:10]:
            print(f"     {uid}: {count} 视频, {diggs:,} 点赞")
        return

    # 扫描本地视频
    print("\n📁 扫描本地视频文件...")
    local_videos = scan_local_videos()
    print(f"   找到 {len(local_videos)} 个本地视频")

    if args.fetch:
        # 弃用警告
        print("\n" + "=" * 60)
        print("⚠️  警告: --fetch 选项已废弃")
        print("   推荐使用 download-v2.py 重新下载视频，会自动保存统计数据")
        print("   用法: python scripts/download-v2.py <主页URL>")
        print("=" * 60)

        # 使用 Playwright 从用户主页获取统计数据
        print("\n🌐 从用户主页获取统计数据...")

        # 获取用户的 sec_user_id
        if args.uid:
            uid = args.uid
        else:
            # 从本地视频推断 uid
            uids = set(v['uid'] for v in local_videos.values())
            if len(uids) == 1:
                uid = list(uids)[0]
            else:
                print(f"❌ 发现多个用户: {uids}，请使用 --uid 指定")
                return

        sec_user_id = get_sec_user_id_from_db(uid)
        if not sec_user_id:
            print(f"❌ 未找到用户 {uid} 的 sec_user_id")
            return

        print(f"   用户 UID: {uid}")
        print(f"   sec_user_id: {sec_user_id[:20]}...\n")

        stats_data = asyncio.run(fetch_video_stats_from_user_page(sec_user_id))

        if stats_data:
            # 合并本地信息和 API 数据
            merged = []
            for aweme_id, local_info in local_videos.items():
                video = local_info.copy()
                if aweme_id in stats_data:
                    video.update(stats_data[aweme_id])
                merged.append(video)

            save_metadata(merged)
    else:
        # 检查 F2 数据库
        print("\n📊 检查 F2 视频数据库...")
        f2_videos = get_video_stats_from_f2_db()
        print(f"   找到 {len(f2_videos)} 条 F2 数据库记录")

        # 创建 F2 数据的索引
        f2_index = {v["aweme_id"]: v for v in f2_videos}

        # 合并数据
        merged = []
        for aweme_id, local_info in local_videos.items():
            video = local_info.copy()
            if aweme_id in f2_index:
                f2_data = f2_index[aweme_id]
                video.update({
                    "desc": f2_data.get("desc", ""),
                    "create_time": f2_data.get("create_time", 0),
                    "duration": f2_data.get("duration", 0),
                    "digg_count": f2_data.get("digg_count", 0),
                    "comment_count": f2_data.get("comment_count", 0),
                    "collect_count": f2_data.get("collect_count", 0),
                    "share_count": f2_data.get("share_count", 0),
                })
            merged.append(video)

        save_metadata(merged)

    # 显示结果
    stats = get_stats_summary()
    print(f"\n📊 当前状态:")
    print(f"   总视频数: {stats['total_videos']}")
    print(f"   有统计数据的视频: {stats['videos_with_stats']}")


if __name__ == "__main__":
    main()