Video Resolve

[project]
name = "video-resolve"
version = "0.1.0"
description = "DaVinci Resolve automation via Python scripting API"
requires-python = ">=3.10"
dependencies = []

"""Add chapter markers to a DaVinci Resolve timeline.

Usage:
    python3 add_markers.py <chapters_json> [--project <name>]
"""

import json
import os
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from resolve_api import connect, add_markers, switch_to_edit_page


def main(chapters_path: str, project_name: str = None):
    with open(chapters_path) as f:
        chapters = json.load(f)

    if isinstance(chapters, dict):
        chapters = chapters.get('chapters', [])

    print("Connecting to DaVinci Resolve...")
    resolve, pm, project = connect()

    if project_name:
        project = pm.LoadProject(project_name)

    switch_to_edit_page(resolve)
    timeline = project.GetCurrentTimeline()
    if not timeline:
        raise RuntimeError("No current timeline")

    fps = float(project.GetSetting("timelineFrameRate") or 25)
    print(f"Adding {len(chapters)} markers to {timeline.GetName()}...")

    add_markers(timeline, chapters, fps=fps)
    print("Done.")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 add_markers.py <chapters_json> [--project <name>]")
        sys.exit(1)

    chapters_path = sys.argv[1]
    project_name = None
    if "--project" in sys.argv:
        idx = sys.argv.index("--project")
        if idx + 1 < len(sys.argv):
            project_name = sys.argv[idx + 1]

    main(chapters_path, project_name)

"""Add overlays (titles and images) to a DaVinci Resolve timeline.

Takes an overlay spec JSON and adds each overlay to the current timeline
as either a Text+ title or an image on a higher video track.

Usage:
    python3 add_overlays.py <overlays_json> [--project <name>]

Requires DaVinci Resolve Studio to be running with the project open.
"""

import json
import os
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from resolve_api import connect, add_title, add_image_overlay, switch_to_edit_page


def add_overlays(overlays_path: str, edl_path: str = None, project_name: str = None):
    """Add overlays from spec to the current Resolve timeline."""

    with open(overlays_path) as f:
        spec = json.load(f)

    overlays = spec.get('overlays', [])
    if not overlays:
        print("No overlays to add.")
        return

    # If EDL provided, build source-to-timeline mapping
    timeline_map = None
    if edl_path:
        with open(edl_path) as f:
            edl = json.load(f)
        kept = [s for s in edl['segments'] if s.get('action') == 'keep']
        timeline_map = []
        tl_pos = 0.0
        for seg in kept:
            timeline_map.append((seg['start'], seg['end'], tl_pos))
            tl_pos += seg['end'] - seg['start']

    def source_to_timeline(src_time):
        """Map source timestamp to edited timeline position."""
        if timeline_map is None:
            return src_time
        for src_start, src_end, tl_start in timeline_map:
            if src_start <= src_time <= src_end:
                return tl_start + (src_time - src_start)
        # Nearest
        best = 0.0
        best_dist = float('inf')
        for src_start, src_end, tl_start in timeline_map:
            for st, tt in [(src_start, tl_start), (src_end, tl_start + src_end - src_start)]:
                if abs(src_time - st) < best_dist:
                    best_dist = abs(src_time - st)
                    best = tt
        return best

    # Connect to Resolve
    print("Connecting to DaVinci Resolve...")
    resolve, pm, project = connect()

    if project_name:
        project = pm.LoadProject(project_name)
        if not project:
            raise RuntimeError(f"Cannot load project: {project_name}")

    switch_to_edit_page(resolve)

    timeline = project.GetCurrentTimeline()
    if not timeline:
        raise RuntimeError("No current timeline. Open a timeline first.")

    fps = float(project.GetSetting("timelineFrameRate") or 25)
    print(f"Timeline: {timeline.GetName()} @ {fps}fps")
    print(f"Adding {len(overlays)} overlays...")

    for overlay in overlays:
        src_start = overlay['timing']['source_start']
        tl_start = source_to_timeline(src_start)
        duration = overlay['timing'].get('display_duration', 5.0)
        start_frame = int(round(tl_start * fps))
        dur_frames = int(round(duration * fps))

        overlay_type = overlay.get('type', 'key-term')
        label = overlay.get('label', '')
        position = overlay.get('position', 'lower-right')

        # Map position names to Resolve coordinates
        pos_map = {
            'lower-right': (0.3, -0.3),
            'lower-third': (0.0, -0.35),
            'lower-left': (-0.3, -0.3),
            'upper-right': (0.3, 0.3),
            'center': (0.0, 0.0),
        }
        pos_x, pos_y = pos_map.get(position, (0.3, -0.3))

        if overlay_type in ('blog-card', 'generic-image') and overlay.get('asset_path'):
            # Image overlay
            asset_path = overlay['asset_path']
            if not os.path.isabs(asset_path):
                asset_path = os.path.join(os.path.dirname(overlays_path), asset_path)

            print(f"  [{overlay['id']}] Image: {label} @ {tl_start:.1f}s ({dur_frames}f)")
            add_image_overlay(
                project, timeline,
                image_path=asset_path,
                track_index=3,
                start_frame=start_frame,
                duration_frames=dur_frames,
                scale=0.4,
                position_x=pos_x,
                position_y=pos_y,
            )
        else:
            # Text title overlay
            url = overlay.get('url', '')
            display_text = label
            if url:
                display_text = f"{label}\n{url}"

            print(f"  [{overlay['id']}] Title: {label} @ {tl_start:.1f}s ({dur_frames}f)")
            add_title(
                timeline,
                text=display_text,
                track_index=2,
                start_frame=start_frame,
                duration_frames=dur_frames,
                position_x=pos_x,
                position_y=pos_y,
            )

    print(f"\nDone. {len(overlays)} overlays added to timeline.")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 add_overlays.py <overlays_json> [--edl <edl_json>] [--project <name>]")
        sys.exit(1)

    overlays_path = sys.argv[1]
    edl_path = None
    project_name = None

    args = sys.argv[2:]
    i = 0
    while i < len(args):
        if args[i] == "--edl" and i + 1 < len(args):
            edl_path = args[i + 1]
            i += 2
        elif args[i] == "--project" and i + 1 < len(args):
            project_name = args[i + 1]
            i += 2
        else:
            i += 1

    add_overlays(overlays_path, edl_path, project_name)

"""Build a DaVinci Resolve project from analysis JSON + EDL.

Takes the same analysis and EDL files produced by the video-editor skill
and creates a complete Resolve project with all cuts applied.

Usage:
    python3 build_project.py <analysis_json> <edl_json> [--name <project_name>]

Requires DaVinci Resolve Studio to be running.
"""

import json
import os
import sys
from pathlib import Path

# Add parent directory to path for resolve_api import
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from resolve_api import (
    connect,
    create_project,
    create_timeline,
    import_media,
    append_clips,
    switch_to_edit_page,
)


def build_project(analysis_path: str, edl_path: str, project_name: str = "Edit"):
    """Build a Resolve project from analysis + EDL."""

    # Load data
    with open(analysis_path) as f:
        analysis = json.load(f)
    with open(edl_path) as f:
        edl = json.load(f)

    meta = analysis['metadata']
    source_file = analysis['source_file']
    video_info = meta.get('video', {})
    fps = video_info.get('fps', 25.0)
    width = video_info.get('width', 1920)
    height = video_info.get('height', 1080)

    # Connect to Resolve
    print("Connecting to DaVinci Resolve...")
    resolve, pm, _ = connect()
    print(f"  Connected: {resolve.GetProductName()} {resolve.GetVersionString()}")

    # Switch to Edit page
    switch_to_edit_page(resolve)

    # Create project
    print(f"Creating project: {project_name}")
    project = create_project(pm, project_name)

    # Import source media
    print(f"Importing: {source_file}")
    media_items = import_media(project, [source_file])
    source_item = media_items[0]
    print(f"  Imported: {source_item.GetName()}")

    # Create timeline
    stem = Path(source_file).stem
    print(f"Creating timeline: {stem}")
    timeline = create_timeline(project, stem, width=width, height=height, fps=fps)

    # Get kept segments from EDL
    kept_segments = [s for s in edl['segments'] if s.get('action') == 'keep']
    print(f"Adding {len(kept_segments)} segments to timeline...")

    # Add segments
    items = append_clips(project, source_item, kept_segments, fps=fps)

    # Apply volume adjustments
    vol_adjusted = 0
    for i, (seg, item) in enumerate(zip(kept_segments, items)):
        vol_db = seg.get('volume_adjust_db', 0)
        if vol_db != 0 and item:
            # Resolve uses linear volume, not dB
            # Approximate: linear = 10^(dB/20)
            import math
            linear = math.pow(10, vol_db / 20.0)
            item.SetProperty("Volume", linear)
            vol_adjusted += 1

    total_kept = sum(s['end'] - s['start'] for s in kept_segments)
    print(f"\nProject built:")
    print(f"  Timeline: {stem}")
    print(f"  Clips: {len(items)}")
    print(f"  Duration: {int(total_kept//60)}:{int(total_kept%60):02d} "
          f"(from {int(meta['duration']//60)}:{int(meta['duration']%60):02d})")
    print(f"  Volume adjustments: {vol_adjusted}")
    print(f"\nOpen DaVinci Resolve to review the edit.")

    return project, timeline


if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: python3 build_project.py <analysis_json> <edl_json> [--name <project_name>]")
        sys.exit(1)

    analysis_path = sys.argv[1]
    edl_path = sys.argv[2]
    project_name = "Edit"

    args = sys.argv[3:]
    for i, arg in enumerate(args):
        if arg == "--name" and i + 1 < len(args):
            project_name = args[i + 1]

    build_project(analysis_path, edl_path, project_name)

"""DaVinci Resolve API wrapper — connect, import, timeline operations.

Handles the boilerplate of connecting to a running Resolve instance
and provides clean helpers for common operations.
"""

import os
import sys
import time
from pathlib import Path
from typing import Dict, List, Optional, Tuple


def _find_resolve_script_module():
    """Find and import DaVinci Resolve's scripting module.

    Resolve's Python module lives in a platform-specific location.
    This function adds the correct path to sys.path.
    """
    # macOS paths for DaVinci Resolve
    resolve_paths = [
        "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules",
        os.path.expanduser("~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules"),
    ]

    for p in resolve_paths:
        if os.path.isdir(p) and p not in sys.path:
            sys.path.insert(0, p)

    # Also check RESOLVE_SCRIPT_API env var
    env_path = os.environ.get("RESOLVE_SCRIPT_API")
    if env_path and os.path.isdir(env_path):
        sys.path.insert(0, os.path.join(env_path, "Modules"))


def connect() -> Tuple:
    """Connect to a running DaVinci Resolve instance.

    Returns (resolve, project_manager, current_project) tuple.
    Raises RuntimeError if Resolve is not running.
    """
    _find_resolve_script_module()

    try:
        import DaVinciResolveScript as dvr
    except ImportError:
        raise RuntimeError(
            "Cannot import DaVinci Resolve scripting module. "
            "Make sure DaVinci Resolve Studio is installed and running. "
            "The free version does not support scripting."
        )

    resolve = dvr.scriptapp("Resolve")
    if resolve is None:
        raise RuntimeError(
            "Cannot connect to DaVinci Resolve. "
            "Make sure it is running before executing this script."
        )

    pm = resolve.GetProjectManager()
    project = pm.GetCurrentProject()
    return resolve, pm, project


def create_project(pm, name: str):
    """Create a new project and return it."""
    project = pm.CreateProject(name)
    if project is None:
        # Project might already exist — try loading it
        project = pm.LoadProject(name)
        if project is None:
            raise RuntimeError(f"Failed to create or load project: {name}")
    return project


def import_media(project, file_paths: List[str]) -> List:
    """Import media files into the project's media pool.

    Returns list of MediaPoolItem objects.
    """
    media_pool = project.GetMediaPool()
    abs_paths = [os.path.abspath(p) for p in file_paths]
    items = media_pool.ImportMedia(abs_paths)
    if not items:
        raise RuntimeError(f"Failed to import media: {abs_paths}")
    return items


def create_timeline(project, name: str, width: int = 1920, height: int = 1080, fps: float = 25.0):
    """Create an empty timeline with specified settings."""
    # Set project settings for the timeline
    project.SetSetting("timelineResolutionWidth", str(width))
    project.SetSetting("timelineResolutionHeight", str(height))
    project.SetSetting("timelineFrameRate", str(fps))

    media_pool = project.GetMediaPool()
    timeline = media_pool.CreateEmptyTimeline(name)
    if timeline is None:
        raise RuntimeError(f"Failed to create timeline: {name}")
    project.SetCurrentTimeline(timeline)
    return timeline


def append_clips(
    project,
    media_pool_item,
    segments: List[dict],
    fps: float = 25.0,
) -> List:
    """Append segments from a single source to the current timeline.

    Each segment needs 'start' and 'end' in seconds.
    Returns list of TimelineItem objects.
    """
    media_pool = project.GetMediaPool()
    timeline_items = []

    for seg in segments:
        start_frame = int(round(seg['start'] * fps))
        end_frame = int(round(seg['end'] * fps))

        clip_info = {
            "mediaPoolItem": media_pool_item,
            "startFrame": start_frame,
            "endFrame": end_frame,
            "mediaType": 1,  # 1 = video+audio
        }

        result = media_pool.AppendToTimeline([clip_info])
        if result:
            timeline_items.extend(result)

    return timeline_items


def add_title(
    timeline,
    text: str,
    track_index: int = 2,
    start_frame: int = 0,
    duration_frames: int = 200,
    position_x: float = 0.0,
    position_y: float = -0.3,
    font_size: float = 0.05,
) -> Optional[object]:
    """Add a Text+ title to the timeline.

    Args:
        timeline: The Timeline object
        text: Text content to display
        track_index: Video track number (2 = first overlay track)
        start_frame: Frame position on timeline
        duration_frames: Duration in frames
        position_x: X position (-0.5 to 0.5, center = 0)
        position_y: Y position (-0.5 to 0.5, center = 0)
        font_size: Font size (0.0 to 1.0)

    Returns:
        TimelineItem or None
    """
    # InsertFusionTitleIntoTimeline places a Fusion Text+ title
    result = timeline.InsertFusionTitleIntoTimeline("Text+")
    if not result:
        # Fallback to standard title
        result = timeline.InsertTitleIntoTimeline("Text")

    # The title gets inserted at the playhead position
    # We need to move it to the right position and set its text
    # This requires accessing the Fusion composition
    return result


def add_image_overlay(
    project,
    timeline,
    image_path: str,
    track_index: int = 3,
    start_frame: int = 0,
    duration_frames: int = 200,
    scale: float = 0.3,
    position_x: float = 0.3,
    position_y: float = -0.3,
) -> Optional[object]:
    """Add an image as an overlay on a higher track.

    Args:
        project: The Project object
        timeline: The Timeline object
        image_path: Path to the image file
        track_index: Video track number (3 = second overlay track)
        start_frame: Frame position on timeline
        duration_frames: Duration in frames
        scale: Scale factor (0.0 to 1.0)
        position_x: X position (-0.5 to 0.5)
        position_y: Y position (-0.5 to 0.5)
    """
    media_pool = project.GetMediaPool()

    # Import the image
    items = media_pool.ImportMedia([os.path.abspath(image_path)])
    if not items:
        print(f"  Warning: failed to import {image_path}")
        return None

    # Add to timeline on specified track
    clip_info = {
        "mediaPoolItem": items[0],
        "startFrame": 0,
        "endFrame": duration_frames,
        "trackIndex": track_index,
        "recordFrame": start_frame,
        "mediaType": 1,
    }

    result = media_pool.AppendToTimeline([clip_info])
    if result:
        item = result[0]
        # Set transform properties
        item.SetProperty("ZoomX", scale)
        item.SetProperty("ZoomY", scale)
        item.SetProperty("Pan", position_x)
        item.SetProperty("Tilt", position_y)
        item.SetProperty("CompositeMode", 0)  # Normal blend mode
        return item
    return None


def add_markers(timeline, markers: List[dict], fps: float = 25.0):
    """Add markers to the timeline.

    Each marker needs 'timeline_secs', 'title', and optionally 'color'.
    """
    for m in markers:
        frame = int(round(m['timeline_secs'] * fps))
        color = m.get('color', 'Blue')
        timeline.AddMarker(
            frame, color,
            m['title'],
            m.get('note', ''),
            1,  # duration in frames
        )


def switch_to_edit_page(resolve):
    """Switch to the Edit page."""
    resolve.OpenPage("edit")
    time.sleep(0.5)

"""Verify DaVinci Resolve scripting environment is set up correctly.

Checks:
1. Resolve Studio is running
2. Python scripting module is accessible
3. Can connect and read project info

Usage:
    python3 setup.py
"""

import os
import subprocess
import sys


def check_resolve_running():
    """Check if DaVinci Resolve is running."""
    result = subprocess.run(
        ['pgrep', '-x', 'DaVinci Resolve'],
        capture_output=True,
    )
    return result.returncode == 0


def check_resolve_installed():
    """Check if DaVinci Resolve is installed."""
    app_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app"
    return os.path.exists(app_path)


def main():
    print("DaVinci Resolve Setup Check")
    print("=" * 40)

    # Check installation
    installed = check_resolve_installed()
    print(f"  Installed: {'Yes' if installed else 'No'}")
    if not installed:
        print("\n  DaVinci Resolve is not installed.")
        print("  Download from: https://www.blackmagicdesign.com/products/davinciresolve")
        print("  Note: Scripting requires DaVinci Resolve Studio ($295 one-time)")
        sys.exit(1)

    # Check if running
    running = check_resolve_running()
    print(f"  Running: {'Yes' if running else 'No'}")
    if not running:
        print("\n  Please start DaVinci Resolve before running scripts.")
        sys.exit(1)

    # Check scripting module
    module_paths = [
        "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules",
        os.path.expanduser("~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules"),
    ]

    module_found = False
    for p in module_paths:
        if os.path.isdir(p):
            print(f"  Scripting module: {p}")
            module_found = True
            sys.path.insert(0, p)
            break

    if not module_found:
        print("\n  Scripting module not found.")
        print("  This usually means you have the free version.")
        print("  DaVinci Resolve Studio ($295) is required for Python scripting.")
        sys.exit(1)

    # Try to connect
    try:
        import DaVinciResolveScript as dvr
        resolve = dvr.scriptapp("Resolve")
        if resolve is None:
            print("\n  Connected to scripting module but Resolve is not responding.")
            print("  Try restarting DaVinci Resolve.")
            sys.exit(1)

        print(f"  Product: {resolve.GetProductName()}")
        print(f"  Version: {resolve.GetVersionString()}")

        pm = resolve.GetProjectManager()
        project = pm.GetCurrentProject()
        if project:
            print(f"  Current project: {project.GetName()}")
        else:
            print("  No project currently open")

        print("\n  Setup OK — ready to use Resolve scripting.")

    except ImportError:
        print("\n  Cannot import DaVinciResolveScript module.")
        print("  Check that DaVinci Resolve Studio is properly installed.")
        sys.exit(1)
    except Exception as e:
        print(f"\n  Error connecting: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

"""Test each Resolve API operation individually on a short test project.

Creates a 10-second test project and verifies:
1. Project creation + media import
2. Timeline creation + clip append with subclips
3. Adding a second video track + placing a title at a specific time
4. Setting the title text via Fusion comp
5. Adding image overlay on track 3 at a specific position
6. Adding timeline markers
"""
import os
import sys
import time

# Setup Resolve scripting module
SCRIPT_MODULES = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules"
if SCRIPT_MODULES not in sys.path:
    sys.path.insert(0, SCRIPT_MODULES)

import DaVinciResolveScript as dvr

PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
SOURCE_VIDEO = os.path.join(PROJECT_ROOT, "raw", "My workflow with Just, Uv Scripts, air, and Agents.mp4")
TEST_PROJECT = "_API_Test"


def connect():
    resolve = dvr.scriptapp("Resolve")
    if not resolve:
        raise RuntimeError("Cannot connect to Resolve. Is it running?")
    pm = resolve.GetProjectManager()
    return resolve, pm


def cleanup(pm):
    """Delete test project if it exists."""
    existing = pm.LoadProject(TEST_PROJECT)
    if existing:
        pm.CloseProject(existing)
    # Need a temp project to delete the test one
    pm.CreateProject("_temp_cleanup")
    pm.DeleteProject(TEST_PROJECT)
    pm.CloseProject(pm.GetCurrentProject())
    pm.DeleteProject("_temp_cleanup")


def test_1_project_and_import(resolve, pm):
    """Test: Create project, import media."""
    print("\n=== TEST 1: Project creation + media import ===")
    resolve.OpenPage("edit")

    project = pm.CreateProject(TEST_PROJECT)
    assert project, "Failed to create project"
    print(f"  Created: {project.GetName()}")

    # Set to 30fps 1920x1080 for test
    project.SetSetting("timelineFrameRate", "30")
    project.SetSetting("timelineResolutionWidth", "1920")
    project.SetSetting("timelineResolutionHeight", "1080")

    media_pool = project.GetMediaPool()
    items = media_pool.ImportMedia([SOURCE_VIDEO])
    assert items and len(items) > 0, "Failed to import media"
    source = items[0]
    print(f"  Imported: {source.GetName()}")

    return project, media_pool, source


def test_2_timeline_and_clips(project, media_pool, source):
    """Test: Create timeline, append two subclips."""
    print("\n=== TEST 2: Timeline + subclip append ===")

    timeline = media_pool.CreateEmptyTimeline("Test Timeline")
    assert timeline, "Failed to create timeline"
    project.SetCurrentTimeline(timeline)
    print(f"  Created timeline: {timeline.GetName()}")

    # Append two 5-second clips (frames 180-330 and 900-1050 at 30fps)
    # Clip 1: 6s-11s of source (frames 180-330)
    # Clip 2: 30s-35s of source (frames 900-1050)
    clips = []
    for start_f, end_f, label in [(180, 330, "Clip A"), (900, 1050, "Clip B")]:
        result = media_pool.AppendToTimeline([{
            "mediaPoolItem": source,
            "startFrame": start_f,
            "endFrame": end_f,
            "mediaType": 1,  # 1 = video+audio
        }])
        assert result, f"Failed to append {label}"
        clips.extend(result)
        print(f"  Appended {label}: frames {start_f}-{end_f}")

    # Verify
    track1_items = timeline.GetItemListInTrack("video", 1)
    print(f"  Track 1 items: {len(track1_items)}")
    for item in track1_items:
        print(f"    {item.GetName()} @ timeline frames {item.GetStart()}-{item.GetEnd()}")

    audio1_items = timeline.GetItemListInTrack("audio", 1)
    print(f"  Audio track 1 items: {len(audio1_items) if audio1_items else 0}")

    return timeline, clips


def test_3_title_at_position(resolve, timeline):
    """Test: Insert Text+ title at a specific timeline position."""
    print("\n=== TEST 3: Insert title at specific position ===")

    # We want the title at frame 30 (1 second into timeline)
    target_frame = 30

    # Move playhead to target position using timecode
    # At 30fps, frame 30 = 00:00:01:00
    fps = 30
    hours = 0
    minutes = 0
    seconds = target_frame // fps
    frames = target_frame % fps
    tc = f"{hours:02d}:{minutes:02d}:{seconds:02d}:{frames:02d}"
    print(f"  Setting playhead to timecode: {tc} (frame {target_frame})")
    result = timeline.SetCurrentTimecode(tc)
    print(f"  SetCurrentTimecode result: {result}")
    print(f"  Current timecode: {timeline.GetCurrentTimecode()}")
    time.sleep(0.3)

    # Insert title
    title_item = timeline.InsertFusionTitleIntoTimeline("Text+")
    print(f"  InsertFusionTitleIntoTimeline result: {title_item}")

    # Check what tracks we have now
    track_count = timeline.GetTrackCount("video")
    print(f"  Video tracks after insert: {track_count}")
    for t in range(1, track_count + 1):
        items = timeline.GetItemListInTrack("video", t)
        if items:
            for item in items:
                print(f"    Track {t}: {item.GetName()} @ {item.GetStart()}-{item.GetEnd()}")

    return title_item


def test_4_set_title_text(timeline):
    """Test: Set the text content of the title via Fusion comp."""
    print("\n=== TEST 4: Set title text via Fusion ===")

    # Find the Text+ item
    track_count = timeline.GetTrackCount("video")
    title_item = None
    for t in range(1, track_count + 1):
        items = timeline.GetItemListInTrack("video", t)
        if items:
            for item in items:
                if "Text" in (item.GetName() or ""):
                    title_item = item
                    break
        if title_item:
            break

    if not title_item:
        print("  ERROR: No title item found!")
        return

    print(f"  Found title: {title_item.GetName()} on track")
    print(f"  Fusion comp count: {title_item.GetFusionCompCount()}")

    comp = title_item.GetFusionCompByIndex(1)
    if not comp:
        print("  ERROR: No Fusion comp found!")
        return

    tools = comp.GetToolList(False)
    print(f"  Tools in comp: {list(tools.keys())}")

    for tool_name, tool in tools.items():
        attrs = tool.GetAttrs()
        reg_id = attrs.get("TOOLS_RegID", "")
        print(f"    Tool: {tool_name}, RegID: {reg_id}")

        if reg_id == "TextPlus":
            # Get current text
            current = tool.GetInput("StyledText")
            print(f"    Current text: '{current}'")

            # Set new text
            tool.SetInput("StyledText", "Hello from API!")
            new_text = tool.GetInput("StyledText")
            print(f"    After SetInput: '{new_text}'")

            # Try setting font and size
            tool.SetInput("Font", "Open Sans")
            tool.SetInput("Style", "Bold")
            tool.SetInput("Size", 0.08)

            # Set position (Center is {1: x, 2: y} in 0-1 range)
            tool.SetInput("Center", {1: 0.5, 2: 0.1})  # Bottom center

            print(f"    Font: {tool.GetInput('Font')}")
            print(f"    Size: {tool.GetInput('Size')}")
            print(f"    Center: {tool.GetInput('Center')}")
            break


def test_5_image_overlay(project, media_pool, timeline):
    """Test: Add an image as overlay on track 3."""
    print("\n=== TEST 5: Image overlay on track 3 ===")

    # Use one of the existing overlay assets
    img_path = os.path.join(PROJECT_ROOT, "claude-edits", "overlays", "assets", "mention_000.png")
    if not os.path.exists(img_path):
        print(f"  SKIP: Image not found at {img_path}")
        return

    # Add video track if needed
    while timeline.GetTrackCount("video") < 3:
        timeline.AddTrack("video")
    print(f"  Video tracks: {timeline.GetTrackCount('video')}")

    # Import image
    img_items = media_pool.ImportMedia([img_path])
    assert img_items, "Failed to import image"
    print(f"  Imported image: {img_items[0].GetName()}")

    # Place on track 3 at frame 60 (2 seconds in), for 90 frames (3 seconds)
    result = media_pool.AppendToTimeline([{
        "mediaPoolItem": img_items[0],
        "startFrame": 0,
        "endFrame": 90,
        "trackIndex": 3,
        "recordFrame": 60,
        "mediaType": 1,
    }])
    print(f"  AppendToTimeline result: {result}")

    if result:
        item = result[0]
        print(f"  Placed: {item.GetName()} @ {item.GetStart()}-{item.GetEnd()}")

        # Set position/scale
        item.SetProperty("ZoomX", 0.3)
        item.SetProperty("ZoomY", 0.3)
        item.SetProperty("Pan", 500.0)   # Right side
        item.SetProperty("Tilt", -400.0) # Lower

        props = item.GetProperty()
        print(f"  ZoomX: {props.get('ZoomX')}, Pan: {props.get('Pan')}, Tilt: {props.get('Tilt')}")

    # Check track 3
    t3_items = timeline.GetItemListInTrack("video", 3)
    print(f"  Track 3 items: {len(t3_items) if t3_items else 0}")


def test_6_markers(timeline):
    """Test: Add markers to timeline."""
    print("\n=== TEST 6: Timeline markers ===")

    timeline.AddMarker(0, "Blue", "Chapter 1: Intro", "", 1)
    timeline.AddMarker(150, "Green", "Chapter 2: Middle", "", 1)

    markers = timeline.GetMarkers()
    print(f"  Markers: {markers}")


def main():
    print("DaVinci Resolve API Test Suite")
    print("=" * 50)

    resolve, pm = connect()
    print(f"Connected: {resolve.GetProductName()} {resolve.GetVersionString()}")

    cleanup(pm)

    project, media_pool, source = test_1_project_and_import(resolve, pm)
    timeline, clips = test_2_timeline_and_clips(project, media_pool, source)
    test_3_title_at_position(resolve, timeline)
    test_4_set_title_text(timeline)
    test_5_image_overlay(project, media_pool, timeline)
    test_6_markers(timeline)

    print("\n" + "=" * 50)
    print("All tests complete. Check the '_API_Test' project in Resolve.")
    print("You should see:")
    print("  - Track 1: Two 5-second video clips with audio")
    print("  - Track 2: A Text+ title saying 'Hello from API!' at ~1s")
    print("  - Track 3: An image overlay at ~2s")
    print("  - Two chapter markers (blue at 0s, green at 5s)")


if __name__ == "__main__":
    main()