Video Wrapper

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
*.egg-info/
dist/
build/

# Virtual Environment
venv/
.venv/

# IDE
.idea/
.vscode/
*.swp
*.swo

# macOS
.DS_Store

# Test artifacts
*.mp4
agi-config.json

# Temporary files
*.tmp
*.temp

moviepy>=1.0.3
pillow>=10.0.0
numpy>=1.24.0
pysrt>=1.1.2
playwright>=1.40.0

"""
Animation functions for video effects
Implements Remotion-style animations in pure Python
"""
import numpy as np


def spring(frame, fps, from_value=0, to_value=1, damping=12, stiffness=200):
    """
    模拟 Remotion 的 spring 物理动画

    参数:
        frame: 当前帧数
        fps: 帧率
        from_value: 起始值
        to_value: 目标值
        damping: 阻尼系数
        stiffness: 刚度系数

    返回:
        当前帧的动画值
    """
    t = frame / fps
    omega = np.sqrt(stiffness)
    zeta = damping / (2 * np.sqrt(stiffness))

    if zeta < 1:  # 欠阻尼
        omega_d = omega * np.sqrt(1 - zeta**2)
        A = 1
        B = zeta * omega / omega_d
        value = (A * np.cos(omega_d * t) + B * np.sin(omega_d * t)) * np.exp(-zeta * omega * t)
    else:  # 临界阻尼或过阻尼
        value = (1 + t) * np.exp(-t)

    return from_value + (to_value - from_value) * (1 - value)


def interpolate(input_value, input_range, output_range, extrapolate='clamp'):
    """
    值映射插值（类似 Remotion 的 interpolate）

    参数:
        input_value: 输入值
        input_range: 输入范围 [min, max]
        output_range: 输出范围 [min, max]
        extrapolate: 'clamp' 或 'extend'
    """
    input_min, input_max = input_range
    output_min, output_max = output_range

    # 归一化输入
    progress = (input_value - input_min) / (input_max - input_min)

    if extrapolate == 'clamp':
        progress = np.clip(progress, 0, 1)

    # 映射到输出范围
    return output_min + progress * (output_max - output_min)


def ease_in_out(t):
    """
    缓入缓出曲线
    """
    return t * t * (3 - 2 * t)

"""
Browser-based renderer using Playwright
Renders HTML/CSS/Anime.js effects to image sequences for video composition
"""
import os
import json
import tempfile
from pathlib import Path


class BrowserRenderer:
    """
    Playwright-based renderer for HTML/CSS/Anime.js effects.
    Captures frames at specified times for video composition.
    """

    def __init__(self, width=1920, height=1080, fps=30):
        self.width = width
        self.height = height
        self.fps = fps
        self._browser = None
        self._playwright = None

        # Get paths relative to this file
        self.base_dir = Path(__file__).parent.parent
        self.templates_dir = self.base_dir / 'templates'
        self.static_dir = self.base_dir / 'static'

    def _ensure_browser(self):
        """Lazily initialize browser"""
        if self._browser is None:
            from playwright.sync_api import sync_playwright
            self._playwright = sync_playwright().start()
            self._browser = self._playwright.chromium.launch(headless=True)
        return self._browser

    def close(self):
        """Clean up browser resources"""
        if self._browser:
            self._browser.close()
            self._browser = None
        if self._playwright:
            self._playwright.stop()
            self._playwright = None

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

    def render_fancy_text_frames(self, config, output_dir=None):
        """
        Render fancy text effect to image sequence.

        Args:
            config: {
                'text': str,
                'style': 'emphasis' | 'term' | 'number',
                'position': {'x': int, 'y': int},
                'startMs': int,
                'endMs': int
            }
            output_dir: Directory to save frames (uses temp dir if None)

        Returns:
            List of frame file paths
        """
        browser = self._ensure_browser()
        page = browser.new_page(viewport={'width': self.width, 'height': self.height})

        # Load template
        template_path = self.templates_dir / 'fancy-text.html'
        page.goto(f'file://{template_path}')

        # Calculate timing
        duration_ms = config['endMs'] - config['startMs']
        total_frames = int(duration_ms / 1000 * self.fps)

        # Prepare config for JavaScript
        js_config = {
            'text': config['text'],
            'style': config.get('style', 'emphasis'),
            'theme': config.get('theme', 'notion'),
            'position': config.get('position', {'x': self.width // 2, 'y': 300}),
            'durationMs': duration_ms
        }

        # Initialize animation with config
        page.evaluate(f'initAnimation({json.dumps(js_config)})')

        # Create output directory
        if output_dir is None:
            output_dir = tempfile.mkdtemp(prefix='fancy_text_')
        output_dir = Path(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)

        # Capture frames
        frame_paths = []
        for frame_idx in range(total_frames):
            time_ms = frame_idx / self.fps * 1000

            # Seek animation to current time
            page.evaluate(f'seekTo({time_ms})')

            # Capture frame with transparent background
            frame_path = output_dir / f'frame_{frame_idx:05d}.png'
            page.screenshot(path=str(frame_path), omit_background=True)
            frame_paths.append(str(frame_path))

        page.close()
        return frame_paths

    def render_term_card_frames(self, config, output_dir=None):
        """
        Render term definition card to image sequence.

        Args:
            config: {
                'chinese': str,
                'english': str,
                'description': str,
                'firstAppearanceMs': int,
                'displayDurationSeconds': float
            }
            output_dir: Directory to save frames (uses temp dir if None)

        Returns:
            List of frame file paths
        """
        browser = self._ensure_browser()
        page = browser.new_page(viewport={'width': self.width, 'height': self.height})

        # Load template
        template_path = self.templates_dir / 'term-card.html'
        page.goto(f'file://{template_path}')

        # Calculate timing
        duration_seconds = config.get('displayDurationSeconds', 6)
        duration_ms = int(duration_seconds * 1000)
        total_frames = int(duration_seconds * self.fps)

        # Default position: top-right corner
        position = config.get('position', {
            'x': self.width - 50 - 400,  # 50px margin, 400px card width
            'y': 50
        })

        # Prepare config for JavaScript
        js_config = {
            'chinese': config['chinese'],
            'english': config['english'],
            'description': config['description'],
            'theme': config.get('theme', 'notion'),
            'position': position,
            'durationMs': duration_ms
        }

        # Initialize animation with config
        page.evaluate(f'initAnimation({json.dumps(js_config)})')

        # Create output directory
        if output_dir is None:
            output_dir = tempfile.mkdtemp(prefix='term_card_')
        output_dir = Path(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)

        # Capture frames
        frame_paths = []
        for frame_idx in range(total_frames):
            time_ms = frame_idx / self.fps * 1000

            # Seek animation to current time
            page.evaluate(f'seekTo({time_ms})')

            # Capture frame with transparent background
            frame_path = output_dir / f'frame_{frame_idx:05d}.png'
            page.screenshot(path=str(frame_path), omit_background=True)
            frame_paths.append(str(frame_path))

        page.close()
        return frame_paths

    def generate_fancy_text_clip(self, keyword, index):
        """
        Generate MoviePy clip from fancy text effect.

        Args:
            keyword: {text, startMs, endMs, style}
            index: Effect index for positioning

        Returns:
            MoviePy ImageSequenceClip
        """
        from moviepy import ImageSequenceClip
        import shutil

        # Calculate position (alternating left/right)
        x_offset = (index % 2) * 400
        y_offset = (index // 2) * 100
        position = {
            'x': self.width // 2 - 300 + x_offset,
            'y': 300 + y_offset
        }

        config = {
            'text': keyword['text'],
            'style': keyword.get('style', 'emphasis'),
            'position': position,
            'startMs': keyword['startMs'],
            'endMs': keyword['endMs']
        }

        # Render frames
        temp_dir = tempfile.mkdtemp(prefix='fancy_text_clip_')
        try:
            frame_paths = self.render_fancy_text_frames(config, temp_dir)

            # Create clip from image sequence
            clip = ImageSequenceClip(frame_paths, fps=self.fps)

            # Set start time
            start_time = keyword['startMs'] / 1000.0
            clip = clip.with_start(start_time)

            return clip
        finally:
            # Clean up temp directory after clip is created
            # Note: MoviePy reads frames lazily, so we need to keep files
            # The caller is responsible for cleanup after video export
            pass

    def generate_term_card_clip(self, term):
        """
        Generate MoviePy clip from term card effect.

        Args:
            term: {chinese, english, description, firstAppearanceMs, displayDurationSeconds}

        Returns:
            MoviePy ImageSequenceClip
        """
        from moviepy import ImageSequenceClip

        config = {
            'chinese': term['chinese'],
            'english': term['english'],
            'description': term['description'],
            'displayDurationSeconds': term.get('displayDurationSeconds', 6)
        }

        # Render frames
        temp_dir = tempfile.mkdtemp(prefix='term_card_clip_')
        frame_paths = self.render_term_card_frames(config, temp_dir)

        # Create clip from image sequence
        clip = ImageSequenceClip(frame_paths, fps=self.fps)

        # Set start time
        start_time = term['firstAppearanceMs'] / 1000.0
        clip = clip.with_start(start_time)

        return clip

    def _render_generic_template(self, template_name, config, output_dir=None):
        """
        Generic renderer for any template.

        Args:
            template_name: Name of the template file (without .html)
            config: Configuration dict including 'durationMs' or 'displayDurationSeconds'
            output_dir: Directory to save frames

        Returns:
            List of frame file paths
        """
        browser = self._ensure_browser()
        page = browser.new_page(viewport={'width': self.width, 'height': self.height})

        # Load template
        template_path = self.templates_dir / f'{template_name}.html'
        page.goto(f'file://{template_path}')

        # Calculate timing
        if 'durationMs' in config:
            duration_ms = config['durationMs']
        elif 'displayDurationSeconds' in config:
            duration_ms = int(config['displayDurationSeconds'] * 1000)
        else:
            duration_ms = 5000  # default 5 seconds

        total_frames = int(duration_ms / 1000 * self.fps)

        # Initialize animation with config
        page.evaluate(f'initAnimation({json.dumps(config)})')

        # Create output directory
        if output_dir is None:
            output_dir = tempfile.mkdtemp(prefix=f'{template_name}_')
        output_dir = Path(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)

        # Capture frames
        frame_paths = []
        for frame_idx in range(total_frames):
            time_ms = frame_idx / self.fps * 1000
            page.evaluate(f'seekTo({time_ms})')
            frame_path = output_dir / f'frame_{frame_idx:05d}.png'
            page.screenshot(path=str(frame_path), omit_background=True)
            frame_paths.append(str(frame_path))

        page.close()
        return frame_paths

    def render_lower_third_frames(self, config, output_dir=None):
        """
        Render lower third (人物条) to image sequence.

        Args:
            config: {
                'name': str,
                'role': str,
                'company': str,
                'theme': str,
                'durationMs': int
            }
        """
        return self._render_generic_template('lower-third', config, output_dir)

    def render_chapter_title_frames(self, config, output_dir=None):
        """
        Render chapter title (章节标题) to image sequence.

        Args:
            config: {
                'number': str (optional, e.g., "Part 1"),
                'title': str,
                'subtitle': str (optional),
                'theme': str,
                'durationMs': int
            }
        """
        return self._render_generic_template('chapter-title', config, output_dir)

    def render_quote_callout_frames(self, config, output_dir=None):
        """
        Render quote callout (金句卡片) to image sequence.

        Args:
            config: {
                'text': str,
                'author': str (optional),
                'theme': str,
                'position': {'x': int, 'y': int},
                'durationMs': int
            }
        """
        # Set default position if not provided
        if 'position' not in config:
            config['position'] = {'x': self.width // 2, 'y': self.height // 2}
        return self._render_generic_template('quote-callout', config, output_dir)

    def render_animated_stats_frames(self, config, output_dir=None):
        """
        Render animated stats (数据动画) to image sequence.

        Args:
            config: {
                'prefix': str (optional),
                'number': int,
                'unit': str (e.g., '%', 'x'),
                'label': str (optional),
                'theme': str,
                'position': {'x': int, 'y': int},
                'durationMs': int
            }
        """
        if 'position' not in config:
            config['position'] = {'x': self.width // 2, 'y': self.height // 2}
        return self._render_generic_template('animated-stats', config, output_dir)

    def render_bullet_points_frames(self, config, output_dir=None):
        """
        Render bullet points (要点列表) to image sequence.

        Args:
            config: {
                'title': str (optional),
                'points': list[str],
                'theme': str,
                'position': {'x': int, 'y': int},
                'durationMs': int
            }
        """
        if 'position' not in config:
            config['position'] = {'x': 100, 'y': 300}
        return self._render_generic_template('bullet-points', config, output_dir)

    def render_social_bar_frames(self, config, output_dir=None):
        """
        Render social media bar (社交媒体条) to image sequence.

        Args:
            config: {
                'platform': 'twitter' | 'weibo' | 'youtube',
                'label': str,
                'handle': str,
                'theme': str,
                'position': {'x': int, 'y': int},
                'durationMs': int
            }
        """
        if 'position' not in config:
            config['position'] = {'x': self.width - 320, 'y': self.height - 130}
        return self._render_generic_template('social-bar', config, output_dir)


def check_playwright_installed():
    """Check if Playwright is installed and chromium is available"""
    try:
        from playwright.sync_api import sync_playwright
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            browser.close()
        return True
    except Exception as e:
        print(f"Playwright check failed: {e}")
        print("To install Playwright and Chromium, run:")
        print("  pip install playwright")
        print("  playwright install chromium")
        return False


if __name__ == '__main__':
    # Test the renderer
    print("Testing BrowserRenderer...")

    if not check_playwright_installed():
        print("Playwright not available, skipping test")
        exit(1)

    with BrowserRenderer(width=1920, height=1080, fps=30) as renderer:
        # Test fancy text
        test_config = {
            'text': '测试花字',
            'style': 'emphasis',
            'startMs': 0,
            'endMs': 2000
        }

        print("Rendering test fancy text frames...")
        frames = renderer.render_fancy_text_frames(test_config)
        print(f"Generated {len(frames)} frames")
        print(f"First frame: {frames[0]}")

        # Test term card
        test_term = {
            'chinese': '人工智能',
            'english': 'Artificial Intelligence',
            'description': '人工智能是计算机科学的一个分支。',
            'firstAppearanceMs': 0,
            'displayDurationSeconds': 3
        }

        print("\nRendering test term card frames...")
        frames = renderer.render_term_card_frames(test_term)
        print(f"Generated {len(frames)} frames")
        print(f"First frame: {frames[0]}")

    print("\nTest complete!")

"""
Content analyzer for interview videos
Analyzes subtitles and suggests visual effects components
"""
import re
import json
from dataclasses import dataclass, field, asdict
from typing import List, Optional
from pathlib import Path


@dataclass
class LowerThirdSuggestion:
    """人物条建议"""
    component: str = "lower_third"
    name: str = ""
    role: str = ""
    company: str = ""
    startMs: int = 0
    durationMs: int = 5000


@dataclass
class ChapterTitleSuggestion:
    """章节标题建议"""
    component: str = "chapter_title"
    number: str = ""
    title: str = ""
    subtitle: str = ""
    startMs: int = 0
    durationMs: int = 4000


@dataclass
class FancyTextSuggestion:
    """
    花字建议

    注意：text 必须是短语形式，概括说话人当时的观点
    - ✅ 正确："AI发展是平滑曲线"、"智能增长类似摩尔定律"
    - ❌ 错误："人工智能"、"摩尔定律"（单词应该用名词卡片）
    """
    component: str = "fancy_text"
    text: str = ""  # 短语观点概括，非单词
    style: str = "emphasis"  # emphasis, term, number
    startMs: int = 0
    endMs: int = 0
    reason: str = ""  # 为什么建议这个


@dataclass
class TermCardSuggestion:
    """名词卡片建议"""
    component: str = "term_card"
    chinese: str = ""
    english: str = ""
    description: str = ""
    firstAppearanceMs: int = 0
    displayDurationSeconds: int = 6


@dataclass
class QuoteCalloutSuggestion:
    """金句卡片建议"""
    component: str = "quote_callout"
    text: str = ""
    author: str = ""
    startMs: int = 0
    durationMs: int = 5000
    reason: str = ""


@dataclass
class AnimatedStatsSuggestion:
    """数据动画建议"""
    component: str = "animated_stats"
    prefix: str = ""
    number: int = 0
    unit: str = ""
    label: str = ""
    startMs: int = 0
    durationMs: int = 4000


@dataclass
class BulletPointsSuggestion:
    """要点列表建议"""
    component: str = "bullet_points"
    title: str = ""
    points: List[str] = field(default_factory=list)
    startMs: int = 0
    durationMs: int = 6000


@dataclass
class SocialBarSuggestion:
    """社交媒体条建议"""
    component: str = "social_bar"
    platform: str = "twitter"  # twitter, weibo, youtube
    label: str = "关注"
    handle: str = ""
    startMs: int = 0
    durationMs: int = 8000  # Default 8 seconds for better visibility


@dataclass
class EffectsSuggestion:
    """完整的特效建议"""
    theme: str = "notion"
    speaker: Optional[LowerThirdSuggestion] = None
    chapters: List[ChapterTitleSuggestion] = field(default_factory=list)
    fancyTexts: List[FancyTextSuggestion] = field(default_factory=list)
    termCards: List[TermCardSuggestion] = field(default_factory=list)
    quotes: List[QuoteCalloutSuggestion] = field(default_factory=list)
    stats: List[AnimatedStatsSuggestion] = field(default_factory=list)
    bulletPoints: List[BulletPointsSuggestion] = field(default_factory=list)
    socialBars: List[SocialBarSuggestion] = field(default_factory=list)


def parse_srt(srt_path: str) -> List[dict]:
    """
    解析 SRT 字幕文件

    返回:
        List of {index, start_ms, end_ms, text}
    """
    with open(srt_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # SRT pattern: index, timestamp, text
    pattern = r'(\d+)\n(\d{2}:\d{2}:\d{2},\d{3}) --> (\d{2}:\d{2}:\d{2},\d{3})\n((?:.*(?:\n|$))*?)(?=\n\d+\n|\Z)'
    matches = re.findall(pattern, content, re.MULTILINE)

    subtitles = []
    for match in matches:
        index = int(match[0])
        start_time = match[1]
        end_time = match[2]
        text = match[3].strip()

        # Convert timestamp to milliseconds
        start_ms = timestamp_to_ms(start_time)
        end_ms = timestamp_to_ms(end_time)

        subtitles.append({
            'index': index,
            'start_ms': start_ms,
            'end_ms': end_ms,
            'text': text
        })

    return subtitles


def timestamp_to_ms(timestamp: str) -> int:
    """Convert SRT timestamp to milliseconds"""
    # Format: HH:MM:SS,mmm
    parts = timestamp.replace(',', ':').split(':')
    hours = int(parts[0])
    minutes = int(parts[1])
    seconds = int(parts[2])
    ms = int(parts[3])
    return hours * 3600000 + minutes * 60000 + seconds * 1000 + ms


def get_full_text(subtitles: List[dict]) -> str:
    """获取完整文本用于分析"""
    return '\n'.join([s['text'] for s in subtitles])


def find_subtitle_at_time(subtitles: List[dict], time_ms: int) -> Optional[dict]:
    """找到指定时间点的字幕"""
    for s in subtitles:
        if s['start_ms'] <= time_ms <= s['end_ms']:
            return s
    return None


def suggestion_to_config(suggestion: EffectsSuggestion) -> dict:
    """
    将建议转换为视频处理配置格式

    Args:
        suggestion: EffectsSuggestion 对象

    Returns:
        可直接用于 video_processor 的配置字典
    """
    config = {
        'theme': suggestion.theme,
        'keyPhrases': [],
        'termDefinitions': [],
        'lowerThirds': [],
        'chapterTitles': [],
        'quotes': [],
        'stats': [],
        'bulletPoints': [],
        'socialBars': []
    }

    # 转换花字
    for ft in suggestion.fancyTexts:
        config['keyPhrases'].append({
            'text': ft.text,
            'style': ft.style,
            'startMs': ft.startMs,
            'endMs': ft.endMs
        })

    # 转换名词卡片
    for tc in suggestion.termCards:
        config['termDefinitions'].append({
            'chinese': tc.chinese,
            'english': tc.english,
            'description': tc.description,
            'firstAppearanceMs': tc.firstAppearanceMs,
            'displayDurationSeconds': tc.displayDurationSeconds
        })

    # 转换人物条
    if suggestion.speaker:
        config['lowerThirds'].append({
            'name': suggestion.speaker.name,
            'role': suggestion.speaker.role,
            'company': suggestion.speaker.company,
            'startMs': suggestion.speaker.startMs,
            'durationMs': suggestion.speaker.durationMs
        })

    # 转换章节标题
    for ch in suggestion.chapters:
        config['chapterTitles'].append({
            'number': ch.number,
            'title': ch.title,
            'subtitle': ch.subtitle,
            'startMs': ch.startMs,
            'durationMs': ch.durationMs
        })

    # 转换金句
    for q in suggestion.quotes:
        config['quotes'].append({
            'text': q.text,
            'author': q.author,
            'startMs': q.startMs,
            'durationMs': q.durationMs
        })

    # 转换数据动画
    for s in suggestion.stats:
        config['stats'].append({
            'prefix': s.prefix,
            'number': s.number,
            'unit': s.unit,
            'label': s.label,
            'startMs': s.startMs,
            'durationMs': s.durationMs
        })

    # 转换要点列表
    for bp in suggestion.bulletPoints:
        config['bulletPoints'].append({
            'title': bp.title,
            'points': bp.points,
            'startMs': bp.startMs,
            'durationMs': bp.durationMs
        })

    # 转换社交媒体条
    for sb in suggestion.socialBars:
        config['socialBars'].append({
            'platform': sb.platform,
            'label': sb.label,
            'handle': sb.handle,
            'startMs': sb.startMs,
            'durationMs': sb.durationMs
        })

    return config


def format_suggestions_for_review(suggestion: EffectsSuggestion) -> str:
    """
    将建议格式化为可读的审核格式

    Returns:
        Markdown 格式的建议列表
    """
    lines = []
    lines.append(f"## 视觉特效建议\n")
    lines.append(f"**主题**: {suggestion.theme}\n")

    # 人物条
    if suggestion.speaker:
        lines.append("### 1. 人物条 (Lower Third)")
        lines.append(f"- **姓名**: {suggestion.speaker.name}")
        lines.append(f"- **职位**: {suggestion.speaker.role}")
        lines.append(f"- **公司**: {suggestion.speaker.company}")
        lines.append(f"- **出现时间**: {suggestion.speaker.startMs}ms")
        lines.append("")

    # 章节标题
    if suggestion.chapters:
        lines.append("### 2. 章节标题 (Chapter Titles)")
        for i, ch in enumerate(suggestion.chapters, 1):
            lines.append(f"**{i}. {ch.number} {ch.title}**")
            if ch.subtitle:
                lines.append(f"   副标题: {ch.subtitle}")
            lines.append(f"   时间: {ch.startMs}ms")
        lines.append("")

    # 花字
    if suggestion.fancyTexts:
        lines.append("### 3. 花字高亮 (Fancy Text)")
        for i, ft in enumerate(suggestion.fancyTexts, 1):
            lines.append(f"{i}. **{ft.text}** ({ft.style})")
            lines.append(f"   时间: {ft.startMs}ms - {ft.endMs}ms")
            if ft.reason:
                lines.append(f"   原因: {ft.reason}")
        lines.append("")

    # 名词卡片
    if suggestion.termCards:
        lines.append("### 4. 名词解释卡片 (Term Cards)")
        for i, tc in enumerate(suggestion.termCards, 1):
            lines.append(f"{i}. **{tc.chinese}** ({tc.english})")
            lines.append(f"   {tc.description}")
            lines.append(f"   时间: {tc.firstAppearanceMs}ms")
        lines.append("")

    # 金句
    if suggestion.quotes:
        lines.append("### 5. 金句卡片 (Quote Callouts)")
        for i, q in enumerate(suggestion.quotes, 1):
            lines.append(f'{i}. "{q.text}"')
            if q.author:
                lines.append(f"   — {q.author}")
            lines.append(f"   时间: {q.startMs}ms")
            if q.reason:
                lines.append(f"   原因: {q.reason}")
        lines.append("")

    # 数据动画
    if suggestion.stats:
        lines.append("### 6. 数据动画 (Animated Stats)")
        for i, s in enumerate(suggestion.stats, 1):
            lines.append(f"{i}. {s.prefix}{s.number}{s.unit}")
            if s.label:
                lines.append(f"   {s.label}")
            lines.append(f"   时间: {s.startMs}ms")
        lines.append("")

    # 要点列表
    if suggestion.bulletPoints:
        lines.append("### 7. 要点列表 (Bullet Points)")
        for i, bp in enumerate(suggestion.bulletPoints, 1):
            lines.append(f"{i}. **{bp.title}**")
            for point in bp.points:
                lines.append(f"   - {point}")
            lines.append(f"   时间: {bp.startMs}ms")
        lines.append("")

    # 社交媒体条
    if suggestion.socialBars:
        lines.append("### 8. 社交媒体条 (Social Bar)")
        for i, sb in enumerate(suggestion.socialBars, 1):
            lines.append(f"{i}. **{sb.platform}**: {sb.handle}")
            lines.append(f"   标签: {sb.label}")
            lines.append(f"   时间: {sb.startMs}ms，时长: {sb.durationMs}ms")
        lines.append("")

    return '\n'.join(lines)


# For Claude to use when analyzing content
ANALYSIS_PROMPT = """
请分析以下访谈字幕内容，并建议适合的视觉特效组件。

## 可用组件类型

1. **人物条 (lower_third)**: 显示嘉宾姓名、职位、公司
   - 通常在视频开头出现

2. **章节标题 (chapter_title)**: 话题切换时的大标题
   - 当话题明显转换时使用

3. **花字 (fancy_text)**: 用短语概括当前观点
   - style: emphasis(强调)、term(术语)、number(数字)
   - ⚠️ 重要规范：
     - 必须是短语形式，概括说话人当时的观点（如"AI发展是平滑曲线"）
     - 不能只是单词（如"人工智能"）
     - 不能与名词卡片的内容重复
     - 位置在字幕上方区域，不遮挡人脸

4. **名词卡片 (term_card)**: 解释专业术语
   - 用于解释专业名词的定义和含义
   - 与花字互补：花字概括观点，名词卡片解释术语

5. **金句卡片 (quote_callout)**: 突出精彩观点
   - 用于特别有洞察力或可引用的完整句子

6. **数据动画 (animated_stats)**: 展示统计数字
   - 当提到具体数字、百分比时使用

7. **要点列表 (bullet_points)**: 总结核心观点
   - 当内容可以概括为几个要点时使用

8. **社交媒体条 (social_bar)**: 关注引导
   - platform: twitter/weibo/youtube
   - 通常在视频结尾出现，时长建议 8-10 秒

## 字幕内容

{subtitle_content}

## 输出格式

请以 JSON 格式输出建议，包含以下字段:
- theme: 推荐主题 (notion/cyberpunk/apple/aurora)
- speaker: 人物条信息
- chapters: 章节标题列表
- fancyTexts: 花字列表（短语观点，非单词）
- termCards: 名词卡片列表（术语解释）
- quotes: 金句列表
- stats: 数据动画列表
- bulletPoints: 要点列表
- socialBars: 社交媒体条列表

每个组件都需要包含 startMs (开始时间毫秒) 字段。
"""


if __name__ == '__main__':
    # Test parsing
    import sys
    if len(sys.argv) > 1:
        srt_path = sys.argv[1]
        subtitles = parse_srt(srt_path)
        print(f"Parsed {len(subtitles)} subtitles")
        for s in subtitles[:5]:
            print(f"  [{s['start_ms']}ms] {s['text'][:50]}...")

"""
Fancy text generator with pop art style effects
"""
from PIL import Image, ImageDraw, ImageFont, ImageFilter
import numpy as np
from animations import spring, interpolate


class FancyTextGenerator:
    def __init__(self, width=1920, height=1080, fps=30):
        self.width = width
        self.height = height
        self.fps = fps

        # 字体配置
        self.font_paths = [
            "/System/Library/Fonts/STHeiti Medium.ttc",  # macOS 中文字体（首选）
            "/System/Library/Fonts/STHeiti Light.ttc",   # macOS 中文字体（备选）
            "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",  # macOS Unicode 字体
            "/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf",  # Linux
            "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",  # Linux 文泉驿
            "C:\\Windows\\Fonts\\msyh.ttc",  # Windows 微软雅黑
            "C:\\Windows\\Fonts\\simhei.ttf",  # Windows 黑体
        ]
        self.font_size = 52

    def _get_font(self, size=None):
        """尝试加载可用字体"""
        if size is None:
            size = self.font_size

        for font_path in self.font_paths:
            try:
                return ImageFont.truetype(font_path, size)
            except:
                continue

        # 如果都失败，使用默认字体
        return ImageFont.load_default()

    def create_text_frame(self, text, frame, start_frame, duration_frames, style='emphasis', position=(960, 300)):
        """
        创建单帧花字图片

        参数:
            text: 文字内容
            frame: 当前帧
            start_frame: 开始帧
            duration_frames: 总帧数
            style: 样式类型 ('emphasis', 'term', 'number')
            position: 位置 (x, y)

        返回:
            PIL Image 对象（RGBA格式）
        """
        relative_frame = frame - start_frame

        # 创建透明画布
        img = Image.new('RGBA', (self.width, self.height), (0, 0, 0, 0))
        draw = ImageDraw.Draw(img)

        # 加载字体
        font = self._get_font()

        # 计算spring动画
        scale = spring(
            relative_frame,
            self.fps,
            from_value=0.8,
            to_value=1.15,
            damping=12,
            stiffness=200
        )

        # 计算淡出
        fade_start = duration_frames - 10
        opacity = interpolate(
            relative_frame,
            [fade_start, duration_frames],
            [1.0, 0.0],
            extrapolate='clamp'
        )

        # 计算抖动
        wobble = np.sin(relative_frame * 0.2) * 3  # 度数

        # 根据样式选择颜色
        if style == 'emphasis':
            # 黄色主体 + 红色描边
            text_color = (255, 237, 78)  # 黄色
            stroke_color = (255, 23, 68)  # 红色
            stroke_width = 4
        elif style == 'term':
            # 青色主体 + 品红描边
            text_color = (0, 229, 255)  # 青色
            stroke_color = (233, 30, 99)  # 品红
            stroke_width = 4
        else:  # number
            # 橙色主体 + 深蓝描边
            text_color = (255, 109, 0)  # 橙色
            stroke_color = (26, 35, 126)  # 深蓝
            stroke_width = 4

        # 添加透明度
        text_color_with_alpha = (*text_color, int(255 * opacity))
        stroke_color_with_alpha = (*stroke_color, int(255 * opacity))

        # 获取文字边界
        bbox = draw.textbbox((0, 0), text, font=font)
        text_width = bbox[2] - bbox[0]
        text_height = bbox[3] - bbox[1]

        # 创建临时图像（足够大以容纳旋转后的文字）
        temp_size = int(max(text_width, text_height) * 2 * scale) + 100
        temp_img = Image.new('RGBA', (temp_size, temp_size), (0, 0, 0, 0))
        temp_draw = ImageDraw.Draw(temp_img)

        # 在临时图像中心绘制文字
        temp_center = temp_size // 2
        text_x = temp_center - text_width // 2
        text_y = temp_center - text_height // 2

        # 绘制描边（通过偏移绘制多次）
        for offset_x in range(-stroke_width, stroke_width + 1):
            for offset_y in range(-stroke_width, stroke_width + 1):
                if offset_x != 0 or offset_y != 0:
                    temp_draw.text(
                        (text_x + offset_x, text_y + offset_y),
                        text,
                        font=font,
                        fill=stroke_color_with_alpha
                    )

        # 绘制主文字
        temp_draw.text((text_x, text_y), text, font=font, fill=text_color_with_alpha)

        # 应用缩放和旋转
        scaled_size = (int(temp_size * scale), int(temp_size * scale))
        temp_img = temp_img.resize(scaled_size, Image.Resampling.LANCZOS)
        temp_img = temp_img.rotate(wobble, expand=True, resample=Image.Resampling.BICUBIC)

        # 添加阴影（drop shadow）
        shadow = temp_img.copy()
        shadow = shadow.filter(ImageFilter.GaussianBlur(radius=5))

        # 将临时图像粘贴到主画布
        paste_x = position[0] - temp_img.width // 2 + 6  # 阴影偏移
        paste_y = position[1] - temp_img.height // 2 + 6
        img.paste(shadow, (paste_x, paste_y), shadow)

        paste_x = position[0] - temp_img.width // 2
        paste_y = position[1] - temp_img.height // 2
        img.paste(temp_img, (paste_x, paste_y), temp_img)

        return img

    def generate_text_clip(self, keyword, index):
        """
        生成完整的花字视频片段

        参数:
            keyword: {text, startMs, endMs, style}
            index: 花字索引（用于定位）

        返回:
            MoviePy VideoClip
        """
        from moviepy import VideoClip

        start_time = keyword['startMs'] / 1000.0
        end_time = keyword['endMs'] / 1000.0
        duration = end_time - start_time

        start_frame = int(start_time * self.fps)
        duration_frames = int(duration * self.fps)

        # 计算位置（左右交替）
        x_offset = (index % 2) * 400
        y_offset = (index // 2) * 100
        position = (self.width // 2 - 300 + x_offset, 300 + y_offset)

        # 生成每一帧
        def make_frame(t):
            frame = int(t * self.fps)
            img = self.create_text_frame(
                keyword['text'],
                start_frame + frame,
                start_frame,
                duration_frames,
                keyword['style'],
                position
            )
            return np.array(img)

        clip = VideoClip(make_frame, duration=duration)
        clip = clip.with_start(start_time)

        return clip

"""
Term definition card generator
"""
from PIL import Image, ImageDraw, ImageFont
import numpy as np
from animations import spring, interpolate


class TermCardGenerator:
    def __init__(self, width=1920, height=1080, fps=30):
        self.width = width
        self.height = height
        self.fps = fps

        # 卡片配置
        self.card_width = 400
        self.card_height = 250
        self.position = (self.width - 50 - self.card_width, 50)  # 右上角

        # 字体路径
        self.font_paths_zh = [
            "/System/Library/Fonts/STHeiti Medium.ttc",  # macOS 华文黑体（首选）
            "/System/Library/Fonts/STHeiti Light.ttc",   # macOS 华文黑体细体
            "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",  # macOS Unicode
            "/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf",  # Linux
            "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",  # Linux 文泉驿
            "C:\\Windows\\Fonts\\msyh.ttc",  # Windows 微软雅黑
            "C:\\Windows\\Fonts\\simhei.ttf",  # Windows 黑体
        ]
        self.font_paths_en = [
            "/System/Library/Fonts/Supplemental/Arial.ttf",  # macOS
            "/System/Library/Fonts/Helvetica.ttc",  # macOS
            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",  # Linux
            "C:\\Windows\\Fonts\\arial.ttf",  # Windows
        ]

    def _get_font(self, font_paths, size):
        """尝试加载可用字体"""
        for font_path in font_paths:
            try:
                return ImageFont.truetype(font_path, size)
            except:
                continue
        return ImageFont.load_default()

    def create_card_frame(self, term, frame, start_frame, duration_frames):
        """
        创建单帧卡片图片

        参数:
            term: {chinese, english, description, displayDurationSeconds}
            frame: 当前帧
            start_frame: 开始帧
            duration_frames: 总帧数

        返回:
            PIL Image 对象（RGBA格式）
        """
        relative_frame = frame - start_frame

        # 创建透明画布
        img = Image.new('RGBA', (self.width, self.height), (0, 0, 0, 0))

        # Spring 滑入动画
        slide_progress = spring(
            relative_frame,
            self.fps,
            from_value=0,
            to_value=1,
            damping=15,
            stiffness=180
        )

        translate_x = interpolate(
            slide_progress,
            [0, 1],
            [100, 0],
            extrapolate='clamp'
        )

        scale = interpolate(
            slide_progress,
            [0, 1],
            [0.8, 1.0],
            extrapolate='clamp'
        )

        # 淡出动画
        exit_start = duration_frames - int(0.5 * self.fps)
        opacity = interpolate(
            relative_frame,
            [exit_start, duration_frames],
            [1.0, 0.0],
            extrapolate='clamp'
        )

        # 呼吸效果
        breathe = np.sin(relative_frame * 0.1) * 2

        # 创建卡片图像
        card_width = int(self.card_width * scale)
        card_height = int(self.card_height * scale)
        card_img = Image.new('RGBA', (card_width, card_height), (0, 0, 0, 0))
        card_draw = ImageDraw.Draw(card_img)

        # 绘制卡片背景（圆角矩形）
        bg_color = (0, 0, 0, int(217 * opacity))  # rgba(0,0,0,0.85) * opacity
        card_draw.rounded_rectangle(
            [(0, 0), (card_width, card_height)],
            radius=16,
            fill=bg_color
        )

        # 绘制渐变边框（简化版，使用多层矩形模拟）
        for i in range(2):
            border_alpha = int(255 * opacity * (1 - i * 0.5))
            border_colors = [
                (255, 215, 0, border_alpha),   # 金色
                (78, 205, 196, border_alpha),  # 青色
                (255, 107, 107, border_alpha)  # 红色
            ]
            color_index = (int(relative_frame * 0.02) + i) % len(border_colors)
            card_draw.rounded_rectangle(
                [(i, i), (card_width - i, card_height - i)],
                radius=16,
                outline=border_colors[color_index],
                width=2
            )

        # 加载字体
        title_font = self._get_font(self.font_paths_zh, 32)
        subtitle_font = self._get_font(self.font_paths_en, 16)
        desc_font = self._get_font(self.font_paths_zh, 16)

        # 标题（中文术语）
        title_color = (255, 215, 0, int(255 * opacity))  # 金色
        card_draw.text((24, 24), term['chinese'], font=title_font, fill=title_color)

        # 副标题（英文）
        subtitle_color = (176, 176, 176, int(255 * opacity))  # 灰色
        card_draw.text((24, 64), term['english'], font=subtitle_font, fill=subtitle_color)

        # 描述
        desc_color = (224, 224, 224, int(255 * opacity))  # 浅灰

        # 简单的文字换行
        description = term['description']
        max_width = card_width - 48
        lines = []
        words = description
        # 简化版：每30个字符一行
        for i in range(0, len(words), 30):
            lines.append(words[i:i+30])

        y_pos = 100
        for line in lines[:4]:  # 最多4行
            card_draw.text((24, y_pos), line, font=desc_font, fill=desc_color)
            y_pos += 24

        # 计算最终位置
        final_x = self.position[0] + translate_x + breathe
        final_y = self.position[1]

        # 粘贴卡片到主画布
        img.paste(card_img, (int(final_x), int(final_y)), card_img)

        return img

    def generate_card_clip(self, term):
        """
        生成完整的卡片视频片段
        """
        from moviepy import VideoClip

        start_time = term['firstAppearanceMs'] / 1000.0
        duration = term.get('displayDurationSeconds', 6)

        start_frame = int(start_time * self.fps)
        duration_frames = int(duration * self.fps)

        def make_frame(t):
            frame = int(t * self.fps)
            img = self.create_card_frame(
                term,
                start_frame + frame,
                start_frame,
                duration_frames
            )
            return np.array(img)

        clip = VideoClip(make_frame, duration=duration)
        clip = clip.with_start(start_time)

        return clip

#!/usr/bin/env python3
"""
Interview video processor - Main script
Adds fancy text and term definition cards to interview videos

Supports two rendering backends:
- browser: HTML/CSS/Anime.js via Playwright (default, better visual quality)
- pil: Python PIL (fallback, no additional dependencies)
"""
import json
import sys
import os
import argparse
import shutil
import tempfile

# Add src directory to Python path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from moviepy import VideoFileClip, CompositeVideoClip


def check_browser_renderer_available():
    """Check if browser renderer (Playwright) is available"""
    try:
        from browser_renderer import check_playwright_installed
        return check_playwright_installed()
    except ImportError:
        return False


def process_video(video_path, subtitle_path, config_path, output_path, renderer='auto'):
    """
    主处理函数

    参数:
        video_path: 输入视频路径
        subtitle_path: 字幕文件路径（目前未使用，保留用于将来扩展）
        config_path: 配置文件路径
        output_path: 输出视频路径
        renderer: 渲染器类型 ('browser', 'pil', 'auto')
    """
    print(f"🎬 正在处理视频: {video_path}")

    # 验证输入文件存在
    if not os.path.exists(video_path):
        print(f"❌ 错误: 视频文件不存在: {video_path}")
        sys.exit(1)

    if not os.path.exists(config_path):
        print(f"❌ 错误: 配置文件不存在: {config_path}")
        sys.exit(1)

    # 确定渲染器
    if renderer == 'auto':
        if check_browser_renderer_available():
            renderer = 'browser'
            print("🌐 使用浏览器渲染器 (HTML/CSS/Anime.js)")
        else:
            renderer = 'pil'
            print("🎨 使用 PIL 渲染器 (Playwright 不可用)")
    elif renderer == 'browser':
        if not check_browser_renderer_available():
            print("❌ 错误: 浏览器渲染器不可用")
            print("请运行以下命令安装:")
            print("  pip install playwright")
            print("  playwright install chromium")
            sys.exit(1)
        print("🌐 使用浏览器渲染器 (HTML/CSS/Anime.js)")
    else:
        print("🎨 使用 PIL 渲染器")

    # 1. 加载配置
    print("📋 加载配置文件...")
    with open(config_path, 'r', encoding='utf-8') as f:
        config = json.load(f)

    # 2. 加载原始视频
    print("📹 加载原始视频...")
    video = VideoFileClip(video_path)
    print(f"   - 分辨率: {video.w}x{video.h}")
    print(f"   - 帧率: {video.fps} fps")
    print(f"   - 时长: {video.duration:.2f} 秒")

    # Track temp directories for cleanup
    temp_dirs = []

    try:
        if renderer == 'browser':
            text_clips, card_clips = _generate_clips_browser(
                config, video.w, video.h, video.fps, temp_dirs
            )
        else:
            text_clips, card_clips = _generate_clips_pil(
                config, video.w, video.h, video.fps
            )

        # 5. 合成所有图层
        print("🎨 合成视频图层...")
        all_clips = [video] + text_clips + card_clips
        final_video = CompositeVideoClip(all_clips, size=(video.w, video.h))

        # 6. 导出最终视频
        print(f"💾 导出最终视频到: {output_path}")
        print("   (这可能需要几分钟，请耐心等待...)")
        final_video.write_videofile(
            output_path,
            codec='libx264',
            audio_codec='aac',
            fps=video.fps,
            preset='medium',
            threads=4,
            logger='bar'  # 显示进度条
        )

        # 清理
        video.close()
        final_video.close()

    finally:
        # Clean up temp directories
        for temp_dir in temp_dirs:
            if os.path.exists(temp_dir):
                shutil.rmtree(temp_dir, ignore_errors=True)

    print("✅ 处理完成！")
    print(f"📁 输出文件: {output_path}")


def _generate_clips_browser(config, width, height, fps, temp_dirs):
    """Generate clips using browser renderer"""
    from browser_renderer import BrowserRenderer
    from moviepy import ImageSequenceClip

    all_effect_clips = []

    # Get theme from config (default: notion)
    theme = config.get('theme', 'notion')
    print(f"🎨 主题: {theme}")

    with BrowserRenderer(width=width, height=height, fps=fps) as renderer:

        # 1. 生成人物条片段
        lower_thirds = config.get('lowerThirds', [])
        if lower_thirds:
            print(f"👤 生成人物条 ({len(lower_thirds)} 个)...")
            for i, lt in enumerate(lower_thirds):
                print(f"   - 人物条: {lt['name']}")
                temp_dir = tempfile.mkdtemp(prefix=f'lower_third_{i}_')
                temp_dirs.append(temp_dir)

                lt_config = {
                    'name': lt['name'],
                    'role': lt.get('role', ''),
                    'company': lt.get('company', ''),
                    'theme': theme,
                    'durationMs': lt.get('durationMs', 5000)
                }
                frame_paths = renderer.render_lower_third_frames(lt_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(lt['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 2. 生成章节标题片段
        chapters = config.get('chapterTitles', [])
        if chapters:
            print(f"📑 生成章节标题 ({len(chapters)} 个)...")
            for i, ch in enumerate(chapters):
                print(f"   - 章节: {ch['title']}")
                temp_dir = tempfile.mkdtemp(prefix=f'chapter_{i}_')
                temp_dirs.append(temp_dir)

                ch_config = {
                    'number': ch.get('number', ''),
                    'title': ch['title'],
                    'subtitle': ch.get('subtitle', ''),
                    'theme': theme,
                    'durationMs': ch.get('durationMs', 4000)
                }
                frame_paths = renderer.render_chapter_title_frames(ch_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(ch['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 3. 生成花字片段
        key_phrases = config.get('keyPhrases', [])
        if key_phrases:
            print(f"✨ 生成花字动画 ({len(key_phrases)} 个)...")
            for i, phrase in enumerate(key_phrases):
                print(f"   - 花字 {i+1}: {phrase['text']}")
                temp_dir = tempfile.mkdtemp(prefix=f'fancy_text_{i}_')
                temp_dirs.append(temp_dir)

                # Calculate position: above subtitles area, alternating left/right
                # Subtitles typically at bottom 15-20% of screen, so place fancy text at top 15-25%
                x_offset = (i % 2) * 300  # Slight horizontal offset for variety
                position = phrase.get('position', {
                    'x': width // 2 - 150 + x_offset,
                    'y': 120 + (i % 3) * 40  # Top area: 120-200px from top
                })

                frame_config = {
                    'text': phrase['text'],
                    'style': phrase.get('style', 'emphasis'),
                    'theme': theme,
                    'position': position,
                    'startMs': phrase['startMs'],
                    'endMs': phrase['endMs']
                }
                frame_paths = renderer.render_fancy_text_frames(frame_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(phrase['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 4. 生成名词卡片片段
        term_defs = config.get('termDefinitions', [])
        if term_defs:
            print(f"📋 生成名词卡片 ({len(term_defs)} 个)...")
            for i, term in enumerate(term_defs):
                print(f"   - 卡片: {term['chinese']}")
                temp_dir = tempfile.mkdtemp(prefix=f'term_card_{i}_')
                temp_dirs.append(temp_dir)

                card_config = {
                    'chinese': term['chinese'],
                    'english': term['english'],
                    'description': term['description'],
                    'theme': theme,
                    'displayDurationSeconds': term.get('displayDurationSeconds', 6)
                }
                frame_paths = renderer.render_term_card_frames(card_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(term['firstAppearanceMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 5. 生成金句卡片片段
        quotes = config.get('quotes', [])
        if quotes:
            print(f"💬 生成金句卡片 ({len(quotes)} 个)...")
            for i, quote in enumerate(quotes):
                print(f"   - 金句: {quote['text'][:20]}...")
                temp_dir = tempfile.mkdtemp(prefix=f'quote_{i}_')
                temp_dirs.append(temp_dir)

                quote_config = {
                    'text': quote['text'],
                    'author': quote.get('author', ''),
                    'theme': theme,
                    'position': quote.get('position', {'x': width // 2, 'y': height // 2}),
                    'durationMs': quote.get('durationMs', 5000)
                }
                frame_paths = renderer.render_quote_callout_frames(quote_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(quote['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 6. 生成数据动画片段
        stats = config.get('stats', [])
        if stats:
            print(f"📊 生成数据动画 ({len(stats)} 个)...")
            for i, stat in enumerate(stats):
                print(f"   - 数据: {stat.get('prefix', '')}{stat['number']}{stat.get('unit', '')}")
                temp_dir = tempfile.mkdtemp(prefix=f'stats_{i}_')
                temp_dirs.append(temp_dir)

                stat_config = {
                    'prefix': stat.get('prefix', ''),
                    'number': stat['number'],
                    'unit': stat.get('unit', ''),
                    'label': stat.get('label', ''),
                    'theme': theme,
                    'position': stat.get('position', {'x': width // 2, 'y': height // 2}),
                    'durationMs': stat.get('durationMs', 4000)
                }
                frame_paths = renderer.render_animated_stats_frames(stat_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(stat['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 7. 生成要点列表片段
        bullet_points = config.get('bulletPoints', [])
        if bullet_points:
            print(f"📝 生成要点列表 ({len(bullet_points)} 个)...")
            for i, bp in enumerate(bullet_points):
                print(f"   - 要点: {bp.get('title', '要点列表')}")
                temp_dir = tempfile.mkdtemp(prefix=f'bullets_{i}_')
                temp_dirs.append(temp_dir)

                bp_config = {
                    'title': bp.get('title', ''),
                    'points': bp['points'],
                    'theme': theme,
                    'position': bp.get('position', {'x': 100, 'y': 300}),
                    'durationMs': bp.get('durationMs', 6000)
                }
                frame_paths = renderer.render_bullet_points_frames(bp_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(bp['startMs'] / 1000.0)
                all_effect_clips.append(clip)

        # 8. 生成社交媒体条片段
        social_bars = config.get('socialBars', [])
        if social_bars:
            print(f"📱 生成社交媒体条 ({len(social_bars)} 个)...")
            for i, sb in enumerate(social_bars):
                print(f"   - 社交: {sb['handle']}")
                temp_dir = tempfile.mkdtemp(prefix=f'social_{i}_')
                temp_dirs.append(temp_dir)

                sb_config = {
                    'platform': sb.get('platform', 'twitter'),
                    'label': sb.get('label', '关注'),
                    'handle': sb['handle'],
                    'theme': theme,
                    'position': sb.get('position', {'x': width - 320, 'y': height - 130}),
                    'durationMs': sb.get('durationMs', 8000)  # Default 8 seconds for social bar
                }
                frame_paths = renderer.render_social_bar_frames(sb_config, temp_dir)
                clip = ImageSequenceClip(frame_paths, fps=fps)
                clip = clip.with_start(sb['startMs'] / 1000.0)
                all_effect_clips.append(clip)

    # Return all clips (split into two lists for compatibility)
    return all_effect_clips, []


def _generate_clips_pil(config, width, height, fps):
    """Generate clips using PIL renderer (legacy)"""
    from fancy_text import FancyTextGenerator
    from term_card import TermCardGenerator

    # 3. 生成花字片段
    print(f"✨ 生成花字动画 ({len(config.get('keyPhrases', []))} 个)...")
    text_gen = FancyTextGenerator(width=width, height=height, fps=fps)
    text_clips = []
    for i, phrase in enumerate(config.get('keyPhrases', [])):
        print(f"   - 花字 {i+1}: {phrase['text']}")
        clip = text_gen.generate_text_clip(phrase, i)
        text_clips.append(clip)

    # 4. 生成卡片片段
    print(f"📋 生成名词卡片 ({len(config.get('termDefinitions', []))} 个)...")
    card_gen = TermCardGenerator(width=width, height=height, fps=fps)
    card_clips = []
    for term in config.get('termDefinitions', []):
        print(f"   - 卡片: {term['chinese']}")
        clip = card_gen.generate_card_clip(term)
        card_clips.append(clip)

    return text_clips, card_clips


def main():
    """命令行入口"""
    parser = argparse.ArgumentParser(
        description='为访谈视频添加花字和名词解释卡片',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  python video_processor.py video.mp4 subs.srt config.json output.mp4
  python video_processor.py video.mp4 subs.srt config.json -r pil  # 使用 PIL 渲染器
  python video_processor.py video.mp4 subs.srt config.json -r browser  # 使用浏览器渲染器
        """
    )

    parser.add_argument('video', help='输入视频文件路径')
    parser.add_argument('subtitles', help='字幕文件路径 (.srt)')
    parser.add_argument('config', help='配置文件路径 (.json)')
    parser.add_argument('output', nargs='?', default=None, help='输出视频路径 (默认: output.mp4)')
    parser.add_argument(
        '-r', '--renderer',
        choices=['auto', 'browser', 'pil'],
        default='auto',
        help='渲染器类型: auto (自动选择), browser (HTML/CSS), pil (Python PIL)'
    )

    args = parser.parse_args()

    # 获取调用脚本时的工作目录（保存在环境变量中）
    original_cwd = os.environ.get('ORIGINAL_CWD', os.getcwd())

    # 默认输出路径为原始工作目录下的 output.mp4
    if args.output:
        output_path = args.output
        # 如果是相对路径，相对于原始工作目录
        if not os.path.isabs(output_path):
            output_path = os.path.join(original_cwd, output_path)
    else:
        output_path = os.path.join(original_cwd, 'output.mp4')

    try:
        process_video(
            args.video,
            args.subtitles,
            args.config,
            output_path,
            renderer=args.renderer
        )
    except Exception as e:
        print(f"❌ 处理失败: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == '__main__':
    main()