#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
通用视频拼接工具
使用filter complex拼接视频片段
用法: python combine_videos.py <adid>
"""

import os
import sys
import subprocess
import glob


def find_video_dir(adid):
    """
    查找视频目录：以adid开头，mp4结尾的文件夹
    """
    search_pattern = f"{adid}*mp4"
    matching_paths = glob.glob(search_pattern)
    
    # 过滤出目录
    matching_dirs = []
    for path in matching_paths:
        if os.path.isdir(path):
            matching_dirs.append(path)
    
    if not matching_dirs:
        print(f"错误：未找到以 {adid} 开头的视频目录")
        return None
    
    # 选择第一个匹配的目录
    video_dir = matching_dirs[0]
    print(f"找到视频目录: {video_dir}")
    return video_dir


def get_video_files(video_dir):
    """
    获取视频文件列表，按索引排序
    """
    video_files = []
    
    for file in os.listdir(video_dir):
        if file.endswith('.mp4'):
            # 提取索引
            try:
                if file.startswith('video_'):
                    idx_str = file.replace('video_', '').replace('.mp4', '')
                    idx = int(idx_str)
                    video_files.append((idx, os.path.join(video_dir, file)))
            except ValueError:
                pass
    
    # 按索引排序
    video_files.sort(key=lambda x: x[0])
    return video_files


def combine_videos_batch(video_files, output_file):
    """
    批量拼接视频
    """
    # 构建输入参数
    input_args = []
    for i, (idx, video_file) in enumerate(video_files):
        input_args.append(f"-i {video_file}")
    
    # 构建filter complex
    input_labels = []
    for i in range(len(video_files)):
        input_labels.append(f"[{i}:v][{i}:a]")
    
    filter_complex = ''.join(input_labels) + f"concat=n={len(video_files)}:v=1:a=1[v][a]"
    
    # 构建完整命令
    cmd = f"ffmpeg -y {' '.join(input_args)} -filter_complex \"{filter_complex}\" -map [v] -map [a] -c:v libx264 -c:a aac {output_file}"
    
    # 执行命令 - 使用binary模式读取输出，避免编码错误
    result = subprocess.run(cmd, shell=True, capture_output=True, text=False)
    
    if result.returncode != 0:
        print(f"错误：拼接视频失败: {output_file}")
        # 尝试解码stderr，处理不同编码
        try:
            stderr = result.stderr.decode('utf-8')
        except UnicodeDecodeError:
            try:
                stderr = result.stderr.decode('gbk')
            except UnicodeDecodeError:
                stderr = result.stderr.decode('latin-1')
        print(stderr)
        return False
    
    return True


def combine_all_videos(adid):
    """
    拼接所有视频片段
    """
    # 查找视频目录
    video_dir = find_video_dir(adid)
    if not video_dir:
        return False
    
    # 获取视频文件
    video_files = get_video_files(video_dir)
    print(f"找到 {len(video_files)} 个视频文件")
    
    if not video_files:
        print("错误：未找到视频文件")
        return False
    
    # 批量处理：每批10个视频
    batch_size = 10
    batches = []
    
    for i in range(0, len(video_files), batch_size):
        batch = video_files[i:i+batch_size]
        batches.append(batch)
    
    print(f"分成 {len(batches)} 批处理")
    
    # 生成批次文件名
    batch_files = []
    for i, batch in enumerate(batches):
        batch_file = f"batch_{i:03d}.mp4"
        batch_files.append(batch_file)
        
        print(f"处理第 {i+1} 批：{len(batch)} 个视频")
        
        # 拼接批次
        if not combine_videos_batch(batch, batch_file):
            return False
    
    # 拼接所有批次
    if len(batch_files) > 1:
        # 构建批次文件列表
        batch_inputs = []
        for i, batch_file in enumerate(batch_files):
            batch_inputs.append(f"-i {batch_file}")
        
        # 构建filter chain
        filter_complex = ''.join([f"[{i}:v][{i}:a]" for i in range(len(batch_files))]) + f"concat=n={len(batch_files)}:v=1:a=1[v][a]"
        
        # 最终输出文件名：使用目录名的后半部分，去掉重复的mp4
        dir_name = os.path.basename(video_dir)
        # 如果目录名以mp4结尾，去掉它
        if dir_name.endswith('mp4'):
            dir_name = dir_name[:-3]
        # 输出到当前目录（srtsegjoin）
        final_output = f"{dir_name}.mp4"
        
        # 构建完整命令
        cmd = f"ffmpeg -y {' '.join(batch_inputs)} -filter_complex \"{filter_complex}\" -map [v] -map [a] -c:v libx264 -c:a aac {final_output}"
        
        # 执行命令 - 使用binary模式读取输出，避免编码错误
        print("拼接所有批次...")
        result = subprocess.run(cmd, shell=True, capture_output=True, text=False)
        
        if result.returncode != 0:
            print(f"错误：拼接批次失败")
            # 尝试解码stderr，处理不同编码
            try:
                stderr = result.stderr.decode('utf-8')
            except UnicodeDecodeError:
                try:
                    stderr = result.stderr.decode('gbk')
                except UnicodeDecodeError:
                    stderr = result.stderr.decode('latin-1')
            print(stderr)
            return False
        
        # 清理批次文件
        for batch_file in batch_files:
            if os.path.exists(batch_file):
                os.remove(batch_file)
    else:
        # 只有一个批次，直接重命名，去掉重复的mp4
        dir_name = os.path.basename(video_dir)
        # 如果目录名以mp4结尾，去掉它
        if dir_name.endswith('mp4'):
            dir_name = dir_name[:-3]
        # 输出到当前目录（srtsegjoin）
        final_output = f"{dir_name}.mp4"
        os.rename(batch_files[0], final_output)
    
    print(f"完成！最终视频: {final_output}")
    return True


def main():
    """
    主函数
    """
    if len(sys.argv) != 2:
        print("用法: python combine_videos.py <adid>")
        print("示例: python combine_videos.py 8442")
        sys.exit(1)
    
    try:
        adid = int(sys.argv[1])
    except ValueError:
        print("错误：adid必须是数字")
        sys.exit(1)
    
    print(f"=== 视频拼接工具 ===")
    print(f"adid: {adid}")
    
    # 复述规则和避坑
    print("\n【拼接规则】")
    print("1. 使用filter complex进行拼接")
    print("2. 批处理：每批10个视频")
    print("3. 最终输出放在根目录")
    print("4. 自动查找以adid开头的视频目录")
    
    print("\n【避坑记录】")
    print("- 错误2：输出文件放在子文件夹，已修复为直接放在根目录")
    
    success = combine_all_videos(adid)
    
    if success:
        print("\n视频拼接完成！")
    else:
        print("\n视频拼接失败！")
        sys.exit(1)


if __name__ == "__main__":
    main()