1from __future__ import annotations
2 
3from pathlib import Path
4 
5from video_timeline_editor.domain.model import Clip, ClipAnalysis, Project
6from video_timeline_editor.domain.services import (
7    DEFAULT_CAPTION_STYLES,
8    DEFAULT_OVERLAY_STYLES,
9    build_caption_ass,
10    compute_clip_timing,
11    merge_styles,
12    retime_caption_words,
13    validate_crop,
14)
15from video_timeline_editor.infrastructure.media import concat_clips, maybe_open, probe_media, render_clip_file
16from video_timeline_editor.infrastructure.transcripts import load_transcript_words, resolve_path
17 
18 
19class TimelineService:
20    def __init__(self, project: Project, timeline_dir: Path):
21        self.project = project
22        self.timeline_dir = timeline_dir
23        self.overlay_styles = merge_styles(DEFAULT_OVERLAY_STYLES, project.overlay_styles)
24        self.caption_styles = merge_styles(DEFAULT_CAPTION_STYLES, project.caption_styles)
25 
26    def analyze_clip(self, clip: Clip) -> ClipAnalysis:
27        source_path = resolve_path(clip.source, self.timeline_dir)
28        if not source_path.exists():
29            raise FileNotFoundError(f"{clip.id}: missing source {source_path}")
30        if clip.crop:
31            validate_crop(clip.crop)
32        media = probe_media(source_path)
33        transcript_words = ()
34        if clip.captions:
35            transcript_words = load_transcript_words(clip.captions, self.timeline_dir)
36        timing = compute_clip_timing(clip, media, transcript_words)
37        caption_words = retime_caption_words(transcript_words, timing) if clip.captions else ()
38        return ClipAnalysis(
39            clip=clip,
40            source_path=source_path,
41            media=media,
42            timing=timing,
43            caption_words=caption_words,
44        )
45 
46    def analyze_timeline(self, clips: list[Clip]) -> dict:
47        total = 0.0
48        manifest_clips = []
49        for clip in clips:
50            analysis = self.analyze_clip(clip)
51            manifest_clips.append(
52                {
53                    "id": clip.id,
54                    "label": clip.label,
55                    "source": str(analysis.source_path),
56                    "nominal_src_in": round(analysis.timing.nominal_in, 3),
57                    "nominal_src_out": round(analysis.timing.nominal_out, 3),
58                    "actual_src_in": round(analysis.timing.actual_in, 3),
59                    "actual_src_out": round(analysis.timing.actual_out, 3),
60                    "duration": round(analysis.timing.output_duration, 3),
61                    "speed": round(clip.speed, 3),
62                    "word_aligned_trim": analysis.timing.word_aligned,
63                    "caption_words": len(analysis.caption_words),
64                    "timeline_in": round(total, 3),
65                    "timeline_out": round(total + analysis.timing.output_duration, 3),
66                }
67            )
68            total += analysis.timing.output_duration
69        return {
70            "project": {
71                "width": self.project.width,
72                "height": self.project.height,
73                "fps": self.project.fps,
74                "output": str(resolve_path(self.project.output, self.timeline_dir)),
75                "work_dir": str(resolve_path(self.project.work_dir, self.timeline_dir)),
76            },
77            "clips": manifest_clips,
78            "total_duration": round(total, 3),
79        }
80 
81    def render_timeline(self, clips: list[Clip], *, open_after: bool = False) -> dict:
82        work_dir = resolve_path(self.project.work_dir, self.timeline_dir)
83        output_path = resolve_path(self.project.output, self.timeline_dir)
84        work_dir.mkdir(parents=True, exist_ok=True)
85        output_path.parent.mkdir(parents=True, exist_ok=True)
86        caption_dir = work_dir / "_captions"
87        caption_dir.mkdir(parents=True, exist_ok=True)
88 
89        rendered_paths = []
90        manifest_clips = []
91        for clip in clips:
92            analysis = self.analyze_clip(clip)
93            caption_ass_path = None
94            if clip.captions and analysis.caption_words:
95                style = dict(self.caption_styles.get(clip.captions.style, self.caption_styles["karaoke"]))
96                ass_text = build_caption_ass(
97                    analysis.caption_words,
98                    clip.captions,
99                    style,
100                    self.project.width,
101                    self.project.height,
102                )
103                caption_ass_path = caption_dir / f"{clip.id}.ass"
104                caption_ass_path.write_text(ass_text)
105            rendered_path = render_clip_file(
106                analysis,
107                width=self.project.width,
108                height=self.project.height,
109                fps=self.project.fps,
110                background=self.project.background,
111                overlay_styles=self.overlay_styles,
112                work_dir=work_dir,
113                caption_ass_path=caption_ass_path,
114            )
115            rendered_paths.append(rendered_path)
116            final_duration = probe_media(rendered_path).duration
117            manifest_clips.append(
118                {
119                    "id": clip.id,
120                    "label": clip.label,
121                    "source": str(analysis.source_path),
122                    "actual_src_in": round(analysis.timing.actual_in, 3),
123                    "actual_src_out": round(analysis.timing.actual_out, 3),
124                    "duration": round(final_duration, 3),
125                    "word_aligned_trim": analysis.timing.word_aligned,
126                    "caption_words": len(analysis.caption_words),
127                    "caption_ass": str(caption_ass_path) if caption_ass_path else None,
128                }
129            )
130        concat_clips(rendered_paths, output_path, work_dir)
131        final_manifest = {
132            "project": {
133                "width": self.project.width,
134                "height": self.project.height,
135                "fps": self.project.fps,
136                "output": str(output_path),
137                "work_dir": str(work_dir),
138            },
139            "clips": manifest_clips,
140            "total_duration": round(probe_media(output_path).duration, 3),
141            "output": str(output_path),
142        }
143        if open_after or self.project.open_after:
144            maybe_open(output_path)
145        return final_manifest
146