"""
视频合成 API 路由
基于编辑器状态进行最终合成
支持同步/异步两种模式，异步模式通过 Celery 任务队列处理
"""
import os
import time
import logging
import subprocess
from typing import List, Optional, Dict, Any
from pathlib import Path

from fastapi import APIRouter, HTTPException, BackgroundTasks
from pydantic import BaseModel

import config
from modules.db_manager import db
from modules.composer import VideoComposer
from modules import ffmpeg_utils, factory
from modules.text_renderer import renderer

# Celery 任务导入 (可选，默认关闭；需要显式开启 USE_CELERY=1)
CELERY_AVAILABLE = False
if str(os.getenv("USE_CELERY", "")).lower() in ("1", "true", "yes", "on"):
    try:
        from api.tasks.video_tasks import compose_from_script_task, compose_from_tracks_task
        CELERY_AVAILABLE = True
    except ImportError:
        CELERY_AVAILABLE = False

logger = logging.getLogger(__name__)
router = APIRouter()


# ============================================================
# Pydantic Models
# ============================================================

class ComposeRequest(BaseModel):
    """合成请求"""
    project_id: str
    
    # 轨道数据（从编辑器状态转换）
    video_clips: List[Dict[str, Any]] = []
    voiceover_clips: List[Dict[str, Any]] = []
    subtitle_clips: List[Dict[str, Any]] = []
    fancy_text_clips: List[Dict[str, Any]] = []
    sticker_clips: List[Dict[str, Any]] = []
    bgm_clip: Optional[Dict[str, Any]] = None
    
    # 全局设置
    voice_type: str = "zh_female_santongyongns_saturn_bigtts"
    bgm_volume: float = 0.15
    output_name: Optional[str] = None


def _validate_no_overlap(clips: List[Dict[str, Any]], *, min_gap: float = 0.0) -> None:
    """Validate clips are non-overlapping when sorted by start time."""
    ordered = sorted(clips, key=lambda x: float(x.get("start") or 0))
    prev_end = 0.0
    for c in ordered:
        start = float(c.get("start") or 0.0)
        dur = float(c.get("duration") or 0.0)
        end = start + dur
        if start + 1e-6 < prev_end - min_gap:
            raise ValueError("视频片段存在重叠，请先在时间轴调整避免同轨道覆盖。")
        prev_end = max(prev_end, end)


def _validate_trim_bounds(video_clips: List[Dict[str, Any]]) -> None:
    """
    Validate trim bounds are sane and, if source_duration is provided, do not exceed it.
    """
    for c in video_clips:
        trim_start = float(c.get("trim_start") or 0.0)
        trim_end = c.get("trim_end")
        duration = float(c.get("duration") or 0.0)
        if trim_end is None:
            trim_end = trim_start + duration
        trim_end = float(trim_end)
        if trim_end <= trim_start + 1e-6:
            raise ValueError("视频片段裁剪区间无效：trim_end 必须大于 trim_start。")

        src_dur = c.get("source_duration")
        if src_dur is not None:
            try:
                src_dur_f = float(src_dur)
                if src_dur_f > 0 and trim_end > src_dur_f + 1e-3:
                    raise ValueError("视频片段裁剪越界：trim_end 超过源视频时长，请先缩短片段或调整 trim。")
            except ValueError:
                raise
            except Exception:
                # ignore parsing errors
                pass


class ComposeResponse(BaseModel):
    success: bool
    message: str
    output_path: Optional[str] = None
    output_url: Optional[str] = None
    task_id: Optional[str] = None


class ComposeStatus(BaseModel):
    status: str  # queued, pending, processing, completed, failed, cancelled
    progress: float = 0
    message: str = ""
    output_path: Optional[str] = None
    output_url: Optional[str] = None


def _persist_job(task_id: str, project_id: str, *, status: str, progress: float, message: str, request: Optional[Dict[str, Any]] = None):
    """Persist status to DB (render_jobs)."""
    try:
        existing = db.get_render_job(task_id)
        if not existing:
            db.create_render_job(task_id, project_id, status=status, progress=progress, message=message, request=request or {})
        else:
            db.update_render_job(task_id, {"status": status, "progress": progress, "message": message})
    except Exception as e:
        logger.debug(f"persist_job failed (non-fatal): {e}")


# ============================================================
# API Endpoints
# ============================================================

@router.post("/render", response_model=ComposeResponse)
async def render_video(request: ComposeRequest, background_tasks: BackgroundTasks):
    """
    异步合成视频
    优先使用 Celery 任务队列（支持水平扩展）
    如果 Celery 不可用，降级为 FastAPI BackgroundTasks
    """
    project = db.get_project(request.project_id)
    if not project:
        raise HTTPException(status_code=404, detail="项目不存在")
    
    # 优先使用 Celery 任务队列
    if CELERY_AVAILABLE:
        try:
            task = compose_from_tracks_task.delay(
                project_id=request.project_id,
                video_clips=request.video_clips,
                voiceover_clips=request.voiceover_clips,
                subtitle_clips=request.subtitle_clips,
                fancy_text_clips=request.fancy_text_clips,
                bgm_clip=request.bgm_clip,
                voice_type=request.voice_type,
                bgm_volume=request.bgm_volume,
                output_name=request.output_name
            )
            
            # 持久化任务记录（便于回溯/重试）
            _persist_job(
                task.id,
                request.project_id,
                status="queued",
                progress=0.0,
                message="合成任务已提交到队列",
                request=request.model_dump(),
            )
            return ComposeResponse(
                success=True,
                message="合成任务已提交到队列",
                task_id=task.id
            )
        except Exception as e:
            logger.warning(f"Celery 任务提交失败，降级为同步模式: {e}")
    
    # 降级：使用 FastAPI BackgroundTasks
    task_id = f"compose_{request.project_id}_{int(time.time())}"
    _persist_job(task_id, request.project_id, status="queued", progress=0.0, message="任务已创建（本地模式）", request=request.model_dump())
    
    background_tasks.add_task(
        _do_compose,
        task_id,
        request
    )
    
    return ComposeResponse(
        success=True,
        message="合成任务已提交",
        task_id=task_id
    )


@router.post("/render-sync", response_model=ComposeResponse)
async def render_video_sync(request: ComposeRequest):
    """
    同步合成视频（适合短视频）
    直接返回结果
    """
    project = db.get_project(request.project_id)
    if not project:
        raise HTTPException(status_code=404, detail="项目不存在")
    
    try:
        # 轻量导出前校验（MVP）：禁止同轨道视频重叠
        if request.video_clips:
            _validate_no_overlap(request.video_clips)
            _validate_trim_bounds(request.video_clips)
        output_path = await _compose_video(None, request)
        
        return ComposeResponse(
            success=True,
            message="合成完成",
            output_path=output_path,
            output_url=f"/static/output/{Path(output_path).name}"
        )
        
    except Exception as e:
        logger.error(f"合成失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/status/{task_id}")
async def get_compose_status(task_id: str):
    """
    获取合成任务状态
    支持 Celery 任务和本地 BackgroundTask 两种模式
    """
    # 先检查是否是 Celery 任务
    if CELERY_AVAILABLE:
        try:
            from celery.result import AsyncResult
            from api.celery_app import celery_app
            
            result = AsyncResult(task_id, app=celery_app)
            
            if result.state == "PENDING":
                _persist_job(task_id, (db.get_render_job(task_id) or {}).get("project_id") or "", status="pending", progress=0.0, message="等待处理...")
                return ComposeStatus(status="pending", progress=0, message="等待处理...")
            elif result.state == "PROGRESS":
                meta = result.info or {}
                _persist_job(task_id, (db.get_render_job(task_id) or {}).get("project_id") or "", status="processing", progress=meta.get("progress", 0), message=meta.get("message", "处理中..."))
                return ComposeStatus(
                    status="processing",
                    progress=meta.get("progress", 0),
                    message=meta.get("message", "处理中...")
                )
            elif result.state == "SUCCESS":
                data = result.result or {}
                _persist_job(task_id, (db.get_render_job(task_id) or {}).get("project_id") or "", status="completed", progress=1.0, message="合成完成")
                try:
                    db.update_render_job(task_id, {"output_path": data.get("output_path"), "output_url": data.get("output_url")})
                except Exception:
                    pass
                return ComposeStatus(
                    status="completed",
                    progress=1.0,
                    message="合成完成",
                    output_path=data.get("output_path"),
                    output_url=data.get("output_url")
                )
            elif result.state == "FAILURE":
                _persist_job(task_id, (db.get_render_job(task_id) or {}).get("project_id") or "", status="failed", progress=0.0, message=str(result.info) if result.info else "任务失败")
                try:
                    db.update_render_job(task_id, {"error": str(result.info) if result.info else "任务失败"})
                except Exception:
                    pass
                return ComposeStatus(
                    status="failed",
                    progress=0,
                    message=str(result.info) if result.info else "任务失败"
                )
            else:
                return ComposeStatus(status=result.state.lower(), progress=0, message=result.state)
                
        except Exception as e:
            logger.debug(f"Celery 状态查询失败: {e}")
    
    # 本地任务/持久化任务：从 DB 取
    job = db.get_render_job(task_id)
    if job:
        return ComposeStatus(
            status=job.get("status") or "pending",
            progress=float(job.get("progress") or 0.0),
            message=job.get("message") or "",
            output_path=job.get("output_path"),
            output_url=job.get("output_url"),
        )
    
    raise HTTPException(status_code=404, detail="任务不存在")


@router.post("/retry/{task_id}", response_model=ComposeResponse)
async def retry_compose(task_id: str, background_tasks: BackgroundTasks):
    """失败任务一键重试：复用原 request 创建新任务。"""
    job = db.get_render_job(task_id)
    if not job or not job.get("request"):
        raise HTTPException(status_code=404, detail="任务不存在或无可重试的请求数据")
    if (job.get("status") or "").lower() not in ("failed", "cancelled"):
        raise HTTPException(status_code=400, detail="仅失败/取消的任务可重试")

    req = job["request"]
    new_id = f"compose_{job.get('project_id')}_{int(time.time())}"
    db.create_render_job(new_id, job.get("project_id") or "", status="queued", progress=0.0, message="重试任务已创建", request=req, parent_id=task_id)
    # 走 BackgroundTasks（不阻塞请求）
    background_tasks.add_task(_do_compose, new_id, ComposeRequest(**req))
    return ComposeResponse(success=True, message="重试任务已提交", task_id=new_id)


@router.post("/quick", response_model=ComposeResponse)
async def quick_compose(project_id: str, bgm_id: Optional[str] = None, async_mode: bool = False):
    """
    快速合成（使用项目默认设置）
    适合工作流一键合成
    
    Args:
        project_id: 项目 ID
        bgm_id: BGM 文件名
        async_mode: 是否使用异步模式（推荐大量并发时使用）
    """
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="项目不存在")
    
    script_data = project.get("script_data")
    if not script_data:
        raise HTTPException(status_code=400, detail="项目缺少脚本数据")
    
    # 获取视频素材
    assets = db.get_assets(project_id, "video")
    video_map = {a["scene_id"]: a["local_path"] for a in assets if a["status"] == "completed"}
    
    if not video_map:
        raise HTTPException(status_code=400, detail="项目缺少视频素材")
    
    # BGM 路径
    bgm_path = None
    if bgm_id:
        bgm_path = str(config.ASSETS_DIR / "bgm" / bgm_id)
        if not os.path.exists(bgm_path):
            bgm_path = None
    
    # 异步模式：提交到 Celery 队列
    if async_mode and CELERY_AVAILABLE:
        try:
            task = compose_from_script_task.delay(
                project_id=project_id,
                script_data=script_data,
                video_map=video_map,
                bgm_path=bgm_path,
                voice_type=config.VOLC_TTS_DEFAULT_VOICE
            )
            
            return ComposeResponse(
                success=True,
                message="合成任务已提交到队列",
                task_id=task.id
            )
        except Exception as e:
            logger.warning(f"Celery 任务提交失败，降级为同步模式: {e}")
    
    # 同步模式
    try:
        composer = VideoComposer(voice_type=config.VOLC_TTS_DEFAULT_VOICE)
        
        output_name = f"final_{project_id}_{int(time.time())}"
        output_path = composer.compose_from_script(
            script=script_data,
            video_map=video_map,
            bgm_path=bgm_path,
            output_name=output_name
        )
        
        # 保存到数据库
        db.save_asset(project_id, 0, "final_video", "completed", local_path=output_path)
        db.update_project_status(project_id, "completed")
        
        return ComposeResponse(
            success=True,
            message="合成完成",
            output_path=output_path,
            output_url=f"/static/output/{Path(output_path).name}"
        )
        
    except Exception as e:
        logger.error(f"快速合成失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


# ============================================================
# Internal Functions
# ============================================================

async def _do_compose(task_id: str, request: ComposeRequest):
    """后台合成任务"""
    try:
        db.update_render_job(task_id, {"status": "processing", "progress": 0.05, "message": "正在准备素材..."})
        
        output_path = await _compose_video(task_id, request)
        
        db.update_render_job(task_id, {
            "status": "completed",
            "progress": 1.0,
            "message": "合成完成",
            "output_path": output_path,
            "output_url": f"/static/output/{Path(output_path).name}",
        })
        
        # 保存到数据库
        db.save_asset(request.project_id, 0, "final_video", "completed", local_path=output_path)
        db.update_project_status(request.project_id, "completed")
        
    except Exception as e:
        logger.error(f"合成任务失败: {e}")
        db.update_render_job(task_id, {"status": "failed", "progress": 0.0, "message": str(e), "error": str(e)})


async def _compose_video(task_id: Optional[str], request: ComposeRequest) -> str:
    """
    执行视频合成
    基于编辑器轨道数据
    """
    timestamp = int(time.time())
    output_name = request.output_name or f"composed_{request.project_id}_{timestamp}"
    
    if task_id:
        db.update_render_job(task_id, {"status": "processing", "progress": 0.10, "message": "收集视频片段..."})
    # 1. 收集视频片段（按时间排序）
    video_clips = sorted(request.video_clips, key=lambda x: x.get("start", 0))
    
    if not video_clips:
        raise ValueError("没有视频片段")
    
    video_paths = []
    video_fades = []
    for clip in video_clips:
        source_path = clip.get("source_path")
        if source_path and os.path.exists(source_path):
            # 如果有裁剪，先裁剪
            trim_start = clip.get("trim_start", 0)
            trim_end = clip.get("trim_end")
            
            # 读取转场参数（存放在 style 里；必须 WYSIWYG：预览=导出）
            style = clip.get("style") or {}
            vf_in = float(style.get("vFadeIn") or style.get("v_fade_in") or 0.0)
            vf_out = float(style.get("vFadeOut") or style.get("v_fade_out") or 0.0)
            # 转场库（WYSIWYG）：仅使用 vTransitionType/vTransitionDur，由 ffmpeg_utils 在拼接阶段实现
            t_type = str(style.get("vTransitionType") or style.get("v_transition_type") or "")
            try:
                t_dur = float(style.get("vTransitionDur") or style.get("v_transition_dur") or 0.0)
            except Exception:
                t_dur = 0.0

            if trim_start > 0 or trim_end:
                # 需要裁剪
                trimmed_path = str(config.TEMP_DIR / f"trim_{timestamp}_{len(video_paths)}.mp4")
                duration = (trim_end or 999) - trim_start
                cmd = [
                    ffmpeg_utils.FFMPEG_PATH, "-y",
                    "-ss", str(trim_start),
                    "-i", source_path,
                    "-t", str(duration),
                    "-c", "copy",
                    trimmed_path
                ]
                ffmpeg_utils._run_ffmpeg(cmd)
                video_paths.append(trimmed_path)
                video_fades.append({"in": max(0.0, vf_in), "out": max(0.0, vf_out), "type": t_type, "dur": max(0.0, t_dur)})
            else:
                video_paths.append(source_path)
                video_fades.append({"in": max(0.0, vf_in), "out": max(0.0, vf_out), "type": t_type, "dur": max(0.0, t_dur)})
    
    # 2. 拼接视频（尽量保留原声；失败则回退无音频）
    if task_id:
        db.update_render_job(task_id, {"progress": 0.25, "message": "拼接视频..."})
    merged_path = str(config.TEMP_DIR / f"{output_name}_merged.mp4")
    ffmpeg_utils.concat_videos_with_audio(video_paths, merged_path, (1080, 1920), fades=video_fades)
    current_video = merged_path
    
    # 添加静音轨（仅当拼接结果没有音轨时）
    if task_id:
        db.update_render_job(task_id, {"progress": 0.30, "message": "添加静音轨..."})
    has_audio = False
    try:
        r = subprocess.run(
            [ffmpeg_utils.FFPROBE_PATH, "-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", current_video],
            capture_output=True,
            text=True,
        )
        has_audio = bool((r.stdout or "").strip())
    except Exception:
        has_audio = False
    if not has_audio:
        silent_path = str(config.TEMP_DIR / f"{output_name}_silent.mp4")
        ffmpeg_utils.add_silence_audio(current_video, silent_path)
        current_video = silent_path
    
    # 获取总时长
    info = ffmpeg_utils.get_video_info(current_video)
    total_duration = float(info.get("duration", 10))
    
    # 3. 生成并混入旁白
    if request.voiceover_clips:
        if task_id:
            db.update_render_job(task_id, {"progress": 0.38, "message": "生成/混入旁白..."})
        mixed_audio_path = str(config.TEMP_DIR / f"{output_name}_mixed_vo.mp3")
        
        # 初始化静音底轨
        ffmpeg_utils._run_ffmpeg([
            ffmpeg_utils.FFMPEG_PATH, "-y",
            "-f", "lavfi", "-i", "anullsrc=r=44100:cl=stereo",
            "-t", str(total_duration),
            "-c:a", "mp3",
            mixed_audio_path
        ])
        
        for i, clip in enumerate(request.voiceover_clips):
            start_time = float(clip.get("start", 0) or 0.0)
            target_duration = float(clip.get("duration", 3) or 3.0)
            vol = float(clip.get("volume", 1.0) or 1.0)
            fade_in = float(clip.get("fade_in", 0.05) or 0.0)
            fade_out = float(clip.get("fade_out", 0.05) or 0.0)
            playback_rate = clip.get("playback_rate", clip.get("playbackRate", None))
            try:
                playback_rate = float(playback_rate) if playback_rate is not None else None
            except Exception:
                playback_rate = None

            # 优先使用已生成的旁白音频（编辑器预览生成）
            existing_path = clip.get("source_path")
            voice_path = None
            if existing_path and os.path.exists(existing_path):
                voice_path = existing_path
            else:
                text = (clip.get("text") or "").strip()
                if not text:
                    continue
                voice_path = factory.generate_voiceover_volcengine(
                    text=text,
                    voice_type=request.voice_type,
                    output_path=str(config.TEMP_DIR / f"{output_name}_vo_{i}.mp3")
                )
                if not voice_path:
                    continue

            # 旁白：纯播放倍速贴合时长（可快可慢，预览/导出一致）
            adjusted_path = str(config.TEMP_DIR / f"{output_name}_vo_adj_{i}.mp3")
            if playback_rate and playback_rate > 0:
                # 先按用户倍速改变语速，再严格裁剪/补齐到片段时长（不再二次计算倍速）
                sped = str(config.TEMP_DIR / f"{output_name}_vo_sp_{i}.mp3")
                ffmpeg_utils.change_audio_speed(voice_path, playback_rate, sped)
                ffmpeg_utils.force_audio_duration(sped, target_duration, adjusted_path)
            else:
                ffmpeg_utils.fit_audio_to_duration_by_speed(voice_path, target_duration, adjusted_path)

            # 音量/淡入淡出（与预览一致）
            processed_path = adjusted_path
            try:
                if vol != 1.0 or fade_in > 0 or fade_out > 0:
                    processed_path = str(config.TEMP_DIR / f"{output_name}_vo_fx_{i}.mp3")
                    fo_st = max(target_duration - fade_out, 0.0)
                    af = (
                        f"afade=t=in:st=0:d={fade_in},"
                        f"afade=t=out:st={fo_st}:d={fade_out},"
                        f"volume={vol}"
                    )
                    ffmpeg_utils._run_ffmpeg([
                        ffmpeg_utils.FFMPEG_PATH, "-y",
                        "-i", adjusted_path,
                        "-filter:a", af,
                        processed_path
                    ])
            except Exception:
                processed_path = adjusted_path

            # 混合
            new_mixed = str(config.TEMP_DIR / f"{output_name}_mixed_{i}.mp3")
            ffmpeg_utils.mix_audio_at_offset(mixed_audio_path, processed_path, start_time, new_mixed, overlay_volume=1.0)
            mixed_audio_path = new_mixed
        
        # 混入视频
        if task_id:
            db.update_render_job(task_id, {"progress": 0.55, "message": "混音合成..."})
        voiced_path = str(config.TEMP_DIR / f"{output_name}_voiced.mp4")
        ffmpeg_utils.mix_audio(
            current_video, mixed_audio_path, voiced_path,
            audio_volume=1.5,
            video_volume=0.2
        )
        current_video = voiced_path
    
    # 4. 添加字幕（使用文本渲染器生成 PNG 叠加，支持字体/颜色/B/I/U）
    if request.subtitle_clips:
        if task_id:
            db.update_render_job(task_id, {"progress": 0.65, "message": "渲染字幕..."})
        overlay_configs = []
        for clip in request.subtitle_clips:
            text = (clip.get("text") or "").strip()
            if not text:
                continue
            style = clip.get("style") or {}
            # WYSIWYG：自动换行交给 TextRenderer（按 max_width 控制）

            # 将前端 style 映射到 renderer style
            r_style = {
                "font_family": style.get("font_family") or style.get("fontFamily") or None,
                "font_size": int(style.get("font_size") or style.get("fontSize") or 60),
                "font_color": style.get("font_color") or style.get("fontColor") or "#FFFFFF",
                "bold": bool(style.get("bold", False)),
                "italic": bool(style.get("italic", False)),
                "underline": bool(style.get("underline", False)),
                # 默认给字幕一点描边，提升可读性
                "stroke": style.get("stroke") or {"color": "#000000", "width": int(style.get("stroke_width") or 5)},
            }

            # 文本框宽度：前端用 0~1（相对画布宽度）控制换行；导出映射到像素（1080）
            try:
                box_w = style.get("box_w") or style.get("boxW") or style.get("max_width") or style.get("maxWidth")
                if isinstance(box_w, (int, float)):
                    if 0 < float(box_w) <= 1:
                        r_style["max_width"] = int(1080 * float(box_w))
                    elif float(box_w) > 1:
                        r_style["max_width"] = int(float(box_w))
            except Exception:
                pass

            img_path = renderer.render(text, r_style, cache=False)

            def _pos(v, axis: str):
                # WYSIWYG：前端 position 允许 0~1（相对画面）或 ffmpeg 表达式字符串
                if isinstance(v, (int, float)):
                    fv = float(v)
                    if 0 <= fv <= 1:
                        return f"({axis}-w)*{fv}" if axis == "W" else f"({axis}-h)*{fv}"
                    return str(fv)
                if isinstance(v, str) and v.strip():
                    return v
                return None

            position = clip.get("position") or {}
            overlay_configs.append({
                "path": img_path,
                "x": _pos(position.get("x"), "W") or "(W-w)/2",
                "y": _pos(position.get("y"), "H") or "H*0.78",
                "start": clip.get("start", 0),
                "duration": clip.get("duration", 3)
            })

        if overlay_configs:
            subtitled_path = str(config.TEMP_DIR / f"{output_name}_subtitled.mp4")
            ffmpeg_utils.overlay_multiple_images(current_video, overlay_configs, subtitled_path)
            current_video = subtitled_path
    
    # 5. 叠加花字
    if request.fancy_text_clips:
        if task_id:
            db.update_render_job(task_id, {"progress": 0.78, "message": "叠加花字..."})
        overlay_configs = []
        for clip in request.fancy_text_clips:
            text = clip.get("text", "")
            if not text:
                continue
            
            style = clip.get("style", {
                "font_size": 72,
                "font_color": "#FFFFFF",
                "stroke": {"color": "#000000", "width": 5}
            })

            # 文本框宽度：0~1（相对画布宽度）-> 像素（1080）
            try:
                box_w = style.get("box_w") or style.get("boxW") or style.get("max_width") or style.get("maxWidth")
                if isinstance(box_w, (int, float)):
                    if 0 < float(box_w) <= 1:
                        style["max_width"] = int(1080 * float(box_w))
                    elif float(box_w) > 1:
                        style["max_width"] = int(float(box_w))
            except Exception:
                pass
            
            img_path = renderer.render(text, style, cache=False)
            
            def _pos(v, axis: str):
                if isinstance(v, (int, float)):
                    fv = float(v)
                    if 0 <= fv <= 1:
                        return f"({axis}-w)*{fv}" if axis == "W" else f"({axis}-h)*{fv}"
                    return str(fv)
                if isinstance(v, str) and v.strip():
                    return v
                return None

            position = clip.get("position", {})
            overlay_configs.append({
                "path": img_path,
                "x": _pos(position.get("x"), "W") or "(W-w)/2",
                "y": _pos(position.get("y"), "H") or "180",
                "start": clip.get("start", 0),
                "duration": clip.get("duration", 5)
            })
        
        if overlay_configs:
            fancy_path = str(config.TEMP_DIR / f"{output_name}_fancy.mp4")
            ffmpeg_utils.overlay_multiple_images(current_video, overlay_configs, fancy_path)
            current_video = fancy_path

    # 5.5 叠加贴纸（PNG/SVG）
    if request.sticker_clips:
        if task_id:
            db.update_render_job(task_id, {"progress": 0.82, "message": "叠加贴纸..."})
        overlay_configs = []
        for i, clip in enumerate(request.sticker_clips):
            src_url = clip.get("source_url") or clip.get("sourceUrl")
            src_path = clip.get("source_path") or clip.get("sourcePath")
            # 贴纸可能来自 /static/assets/...，导出侧优先用 source_path，其次尝试解析 url 到本地路径
            path = src_path
            if not path and isinstance(src_url, str) and src_url.startswith("/static/"):
                # /static/assets/... 映射到容器内 /app/assets/...
                try:
                    rel = src_url.replace("/static/assets/", "")
                    path = str(config.ASSETS_DIR / rel)
                except Exception:
                    path = None
            if not path or not os.path.exists(path):
                continue

            # 规范化为 PNG
            png_path = str(config.TEMP_DIR / f"{output_name}_st_{i}.png")
            try:
                norm = ffmpeg_utils.normalize_sticker_to_png(path, png_path)
            except Exception:
                norm = None
            if not norm or not os.path.exists(norm):
                continue

            pos = clip.get("position") or {}
            x = pos.get("x", 0.8)
            y = pos.get("y", 0.2)
            # x/y: 0~1 视为比例
            def _pos(v, axis: str):
                if isinstance(v, (int, float)):
                    fv = float(v)
                    if 0 <= fv <= 1:
                        return f"({axis}-w)*{fv}" if axis == "W" else f"({axis}-h)*{fv}"
                    return str(fv)
                if isinstance(v, str) and v.strip():
                    return v
                return None

            st = clip.get("style") or {}
            scale = 1.0
            try:
                scale = float(st.get("scale", 1.0) or 1.0)
            except Exception:
                scale = 1.0
            scale = max(0.3, min(3.0, scale))

            # 通过 overlay 的 scale：先 scale 贴纸，再 overlay
            # overlay_multiple_images 不支持单张单独 scale filter，所以这里把 PNG 预缩放成新文件
            scaled_path = str(config.TEMP_DIR / f"{output_name}_st_sc_{i}.png")
            try:
                if abs(scale - 1.0) > 1e-3:
                    ffmpeg_utils._run_ffmpeg([
                        ffmpeg_utils.FFMPEG_PATH, "-y",
                        "-i", norm,
                        "-vf", f"scale=iw*{scale}:ih*{scale}:flags=lanczos",
                        scaled_path
                    ])
                    norm = scaled_path
            except Exception:
                pass

            overlay_configs.append({
                "path": norm,
                "x": _pos(x, "W") or "(W-w)*0.8",
                "y": _pos(y, "H") or "(H-h)*0.2",
                "start": clip.get("start", 0),
                "duration": clip.get("duration", 2),
            })

        if overlay_configs:
            st_path = str(config.TEMP_DIR / f"{output_name}_stickers.mp4")
            ffmpeg_utils.overlay_multiple_images(current_video, overlay_configs, st_path)
            current_video = st_path
    
    # 6. 添加 BGM
    if request.bgm_clip:
        if task_id:
            db.update_render_job(task_id, {"progress": 0.88, "message": "混入 BGM..."})
        bgm_source = request.bgm_clip.get("source_path")
        if bgm_source and os.path.exists(bgm_source):
            bgm_output = str(config.TEMP_DIR / f"{output_name}_bgm.mp4")
            # BGM 参数：优先使用 clip 内配置
            bgm_start = float(request.bgm_clip.get("start", 0) or 0.0)
            bgm_dur = request.bgm_clip.get("duration")
            try:
                bgm_dur = float(bgm_dur) if bgm_dur is not None else None
            except Exception:
                bgm_dur = None
            bgm_vol = float(request.bgm_clip.get("volume", request.bgm_volume) or request.bgm_volume)
            bgm_fade_in = float(request.bgm_clip.get("fade_in", 0.8) or 0.0)
            bgm_fade_out = float(request.bgm_clip.get("fade_out", 0.8) or 0.0)
            bgm_ducking = request.bgm_clip.get("ducking")
            if not isinstance(bgm_ducking, bool):
                bgm_ducking = True
            bgm_duck_volume = float(request.bgm_clip.get("duck_volume", 0.25) or 0.25)

            # 闪避区间：来自旁白时间轴（更可控）
            duck_ranges = None
            if request.voiceover_clips and bgm_ducking:
                duck_ranges = []
                for vc in request.voiceover_clips:
                    s = float(vc.get("start", 0) or 0.0)
                    d = float(vc.get("duration", 0) or 0.0)
                    if d <= 0:
                        continue
                    # 给一点点缓冲，避免边缘咬字突兀
                    duck_ranges.append((max(0.0, s - 0.03), s + d + 0.05))

            ffmpeg_utils.add_bgm(
                current_video, bgm_source, bgm_output,
                bgm_volume=bgm_vol,
                ducking=bool(bgm_ducking),
                duck_volume=bgm_duck_volume,
                duck_ranges=duck_ranges,
                start_time=bgm_start,
                clip_duration=bgm_dur,
                fade_in=bgm_fade_in,
                fade_out=bgm_fade_out,
            )
            current_video = bgm_output
    
    # 7. 输出最终文件
    if task_id:
        db.update_render_job(task_id, {"progress": 0.95, "message": "写出最终文件..."})
    final_path = str(config.OUTPUT_DIR / f"{output_name}.mp4")
    import shutil
    shutil.copy(current_video, final_path)
    
    logger.info(f"合成完成: {final_path}")
    return final_path