GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Headless UI tests of media management: the Link Media dialog opening for a project whose media
//! moved (search a folder, link, the others follow), Project panel offline / proxy badges, the
//! monitors' Toggle Proxies button, Create Proxies and Project Manager dialogs.
//!
//! Set `FILMCRAFT_UI_SNAPSHOT_DIR=<dir>` to also render the window offscreen with wgpu and write PNGs
//! there (`media-*.png`).

use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::mpsc::{Sender, channel};

use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
use filmcraft_engine::Session;
use filmcraft_engine::project::{ItemKind, Label, MediaClip, MediaRef, Project, SequenceSettings, TrackKind};
use filmcraft_media::generators::GeneratorSource;
use filmcraft_media::{DemoScene, Generator, MediaSource};
use filmcraft_time::{FrameRate, Tick, TimeRange};
use filmcraft_ui_egui::FilmcraftApp;
use filmcraft_ui_egui::control::ControlRequest;
use serde_json::{Value, json};

fn tmp_dir(name: &str) -> PathBuf {
    let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
    let d = std::env::temp_dir().join(format!("filmcraft-ui-{name}-{}-{nanos}", std::process::id()));
    std::fs::create_dir_all(&d).unwrap();
    d
}

/// A 24 fps ProRes movie of a demo scene (our own encoder).
fn make_movie(path: &Path, scene: DemoScene, w: u32, h: u32, frames: i64) {
    let rate = FrameRate::FPS_24;
    let dur = rate.tick_of(frames);
    let src = GeneratorSource::new(Generator::Demo(scene), w, h, rate, dur);
    let clip = MediaClip {
        media: MediaRef::Generator(Generator::Demo(scene)),
        info: src.info().clone(),
        interpret: Default::default(),
        mark_in: None,
        mark_out: None,
        markers: vec![],
        offline: false,
        proxy: None,
        identity: None,
    };
    let mut p = Project::new("fixture");
    let item = p.add_item("scene", Label::Iris, ItemKind::Media(Box::new(clip)), None);
    let seq = p.new_sequence("s", SequenceSettings { width: w, height: h, frame_rate: rate, ..Default::default() }, 1, 0, None);
    let mut v = p.make_track_item(item, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, dur), rate).unwrap();
    for e in &mut v.effects {
        filmcraft_engine::project::resolve_auto_points(e, (w, h), (w, h));
    }
    p.sequence_mut(seq).unwrap().video_tracks[0].items.push(v);
    let settings = filmcraft_engine::export::ExportSettings {
        format: filmcraft_engine::export::Format::ProRes,
        path: path.to_string_lossy().into_owned(),
        include_audio: false,
        ..Default::default()
    };
    let shared: filmcraft_media::SharedSource = Arc::new(src);
    let provider = move |id| (id == item).then(|| shared.clone());
    filmcraft_engine::export::export(&Arc::new(p), seq, &settings, &provider, &Default::default()).unwrap();
}

/// `<root>/p.fcproj` with a sequence of `<root>/Media/{Harbour,Night}.mov`; the media folder is
/// then moved to `<root>/Moved/Media`.
fn moved_project(root: &Path) -> String {
    let media = root.join("Media");
    std::fs::create_dir_all(&media).unwrap();
    let files = [media.join("Harbour.mov"), media.join("Night.mov")];
    make_movie(&files[0], DemoScene::OceanSunset, 640, 360, 24);
    make_movie(&files[1], DemoScene::CityNight, 640, 360, 24);
    let mut s = Session::default();
    let r = s.execute("file.import", json!({"paths": files.iter().map(|f| f.to_string_lossy()).collect::<Vec<_>>()})).unwrap();
    let items: Vec<u64> = r["items"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
    let rate = FrameRate::FPS_24;
    let mut p = (*s.project).clone();
    let seq = p.new_sequence("Harbour Cut", SequenceSettings { width: 640, height: 360, frame_rate: rate, ..Default::default() }, 1, 1, None);
    let mut at = Tick::ZERO;
    for it in items {
        let it = filmcraft_engine::project::ItemId(it);
        let d = rate.tick_of(24);
        let mut v = p.make_track_item(it, TrackKind::Video, at, TimeRange::new(Tick::ZERO, d), rate).unwrap();
        for e in &mut v.effects {
            filmcraft_engine::project::resolve_auto_points(e, (640, 360), (640, 360));
        }
        p.sequence_mut(seq).unwrap().video_tracks[0].items.push(v);
        at += d;
    }
    s.project = Arc::new(p);
    let path = root.join("p.fcproj").to_string_lossy().into_owned();
    s.execute("file.save", json!({"path": path})).unwrap();
    drop(s); // Close decoder files before moving their directory on Windows.
    std::fs::create_dir_all(root.join("Moved")).unwrap();
    std::fs::rename(&media, root.join("Moved").join("Media")).unwrap();
    path
}

struct Driver {
    harness: Harness<'static, FilmcraftApp>,
    tx: Sender<ControlRequest>,
    snapshots: Option<PathBuf>,
}

impl Driver {
    fn new(session: Session) -> Self {
        let (tx, rx) = channel();
        let app = FilmcraftApp::new(session).with_control(rx);
        let snapshots = std::env::var_os("FILMCRAFT_UI_SNAPSHOT_DIR").map(PathBuf::from);
        let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
        if snapshots.is_some() {
            b = b.wgpu();
        }
        let harness = b.build_eframe(move |_cc| app);
        let mut d = Driver { harness, tx, snapshots };
        d.frames(4);
        d
    }

    fn frames(&mut self, n: usize) {
        for _ in 0..n {
            let ctx = self.harness.ctx.clone();
            let mut raw = std::mem::take(self.harness.input_mut());
            eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
            *self.harness.input_mut() = raw;
            self.harness.step();
        }
    }

    fn call(&mut self, method: &str, params: Value) -> Value {
        let (req, reply) = ControlRequest::new(method, params.clone());
        self.tx.send(req).unwrap();
        for _ in 0..600 {
            self.frames(1);
            if let Ok(v) = reply.try_recv() {
                return v;
            }
        }
        panic!("no reply to {method} {params}");
    }

    fn ok(&mut self, method: &str, params: Value) -> Value {
        let v = self.call(method, params.clone());
        assert_eq!(v["ok"], json!(true), "{method} {params} failed: {v}");
        v["result"].clone()
    }

    fn exec(&mut self, command: &str, params: Value) -> Value {
        self.ok("engine.execute", json!({"command": command, "params": params}))
    }

    fn click(&mut self, id: &str) {
        self.ok("ui.click", json!({"id": id}));
        self.frames(3);
    }

    fn ids(&mut self, prefix: &str) -> Vec<String> {
        let v = self.ok("ui.elements", json!({"prefix": prefix}));
        v.as_array().unwrap().iter().filter_map(|e| e["id"].as_str().map(str::to_string)).collect()
    }

    fn app(&mut self) -> &mut FilmcraftApp {
        self.harness.state_mut()
    }

    fn snapshot(&mut self, name: &str) {
        let Some(dir) = self.snapshots.clone() else { return };
        self.frames(3);
        let img = match self.harness.render() {
            Ok(i) => i,
            Err(e) => {
                eprintln!("snapshot {name} skipped: {e}");
                return;
            }
        };
        std::fs::create_dir_all(&dir).unwrap();
        let path = dir.join(format!("{name}.png"));
        img.save(&path).unwrap();
        eprintln!("snapshot: {}", path.display());
    }
}

/// #301: Source transport must step by frame index when frame durations need rounding.
#[test]
fn source_transport_steps_every_frame_at_a_fractional_tick_rate() {
    let rate = FrameRate::new(31, 1);
    let generator = Generator::Demo(DemoScene::OceanSunset);
    let src = GeneratorSource::new(generator.clone(), 32, 18, rate, rate.tick_of(41));
    let mut session = Session::default();
    let item = Arc::make_mut(&mut session.project).add_item(
        "31 fps source",
        Label::Iris,
        ItemKind::Media(Box::new(MediaClip {
            media: MediaRef::Generator(generator),
            info: src.info().clone(),
            interpret: Default::default(),
            mark_in: None,
            mark_out: None,
            markers: vec![],
            offline: false,
            proxy: None,
            identity: None,
        })),
        None,
    );
    session.execute("source.open", json!({"item": item.0})).unwrap();
    let mut d = Driver::new(session);
    for frame in 1..=40 {
        d.click("source.transport.src.stepFwd");
        assert_eq!(rate.frame_at(d.app().session.state.source_playhead), frame);
    }
    d.click("source.transport.src.stepFwd");
    assert_eq!(rate.frame_at(d.app().session.state.source_playhead), 40, "stop at the last source frame");
    for frame in (0..40).rev() {
        d.click("source.transport.src.stepBack");
        assert_eq!(rate.frame_at(d.app().session.state.source_playhead), frame);
    }
    d.click("source.transport.src.stepBack");
    assert_eq!(d.app().session.state.source_playhead, Tick::ZERO);
}

/// Source-focused menu/keyboard commands use the same frame grid as the Source toolbar.
#[test]
fn source_menu_steps_use_ordinals_for_explicit_targets_and_focus() {
    let rate = FrameRate::new(31, 1);
    for explicit_source in [true, false] {
        let generator = Generator::Demo(DemoScene::OceanSunset);
        let src = GeneratorSource::new(generator.clone(), 32, 18, rate, rate.tick_of(41));
        let mut session = Session::default();
        session.execute("file.newSequence", json!({"fps": 31, "width": 32, "height": 18})).unwrap();
        session.execute("playhead.set", json!({"frame": 10})).unwrap();
        session.execute("prefs.set", json!({"key": "playback.stepManyFrames", "value": 12})).unwrap();
        let item = Arc::make_mut(&mut session.project).add_item(
            "31 fps menu source",
            Label::Iris,
            ItemKind::Media(Box::new(MediaClip {
                media: MediaRef::Generator(generator),
                info: src.info().clone(),
                interpret: Default::default(),
                mark_in: None,
                mark_out: None,
                markers: vec![],
                offline: false,
                proxy: None,
                identity: None,
            })),
            None,
        );
        session.execute("source.open", json!({"item": item.0})).unwrap();
        let mut d = Driver::new(session);
        d.ok("ui.set", json!({"focused": if explicit_source { "Program" } else { "Source" }}));
        let project = d.app().session.project.clone();
        let history = d.exec("history.list", json!({}));
        let mut source_metadata = d.exec("source.inspect", json!({}));
        source_metadata.as_object_mut().unwrap().remove("playhead");
        let source_params = if explicit_source { json!({"monitor": "source"}) } else { json!({}) };
        for (command, frame) in [
            ("playhead.stepForward", 1),
            ("playhead.stepForward", 2),
            ("playhead.stepBack", 1),
            ("playhead.stepBack", 0),
            ("playhead.stepBack", 0),
            ("playhead.stepForward5", 12),
            ("playhead.stepForward5", 24),
            ("playhead.stepForward5", 36),
            ("playhead.stepForward5", 40),
            ("playhead.stepForward5", 40),
            ("playhead.stepBack5", 28),
            ("playhead.stepBack5", 16),
            ("playhead.stepBack5", 4),
            ("playhead.stepBack5", 0),
            ("playhead.stepBack5", 0),
        ] {
            d.ok("ui.menu.invoke", json!({"id": command, "params": source_params.clone()}));
            let mut source = d.exec("source.inspect", json!({}));
            assert_eq!(source["playhead"], json!(rate.tick_of(frame).0), "{command}, explicit Source target: {explicit_source}");
            source.as_object_mut().unwrap().remove("playhead");
            assert_eq!(source, source_metadata);
            assert_eq!(d.app().session.playhead(), rate.tick_of(10));
            assert!(Arc::ptr_eq(&d.app().session.project, &project), "Source navigation must preserve the document");
            assert_eq!(d.exec("history.list", json!({})), history);
            let state = d.ok("ui.inspect", json!({}));
            assert_eq!(state["playback"]["playing"], json!(false));
            assert_eq!(state["sourcePlayback"]["playing"], json!(false));
        }
        // An explicit Program target takes priority even while Source has focus.
        for (command, frame) in [("playhead.stepForward", 11), ("playhead.stepBack", 10)] {
            d.ok("ui.menu.invoke", json!({"id": command, "params": {"monitor": "program"}}));
            assert_eq!(d.app().session.playhead(), rate.tick_of(frame));
            assert_eq!(d.app().session.state.source_playhead, Tick::ZERO);
            assert!(Arc::ptr_eq(&d.app().session.project, &project));
            assert_eq!(d.exec("history.list", json!({})), history);
        }
    }
}

// Requires the wide Time arithmetic: the accepted Source rate has more than one frame per tick.
fn zero_tick_frame_duration_source() -> (Driver, Tick) {
    let rate = FrameRate::new(i64::MAX, 1000);
    let current = Tick(254_270_016_000_000); // 1001 seconds, beyond the i64 frame-index range.
    assert_eq!(rate.frame_duration(), Tick::ZERO);
    assert_eq!(rate.frame_at(current), i64::MAX);
    assert_eq!(rate.tick_of(i64::MAX), Tick(254_016_000_000_000));
    assert_eq!(rate.snap(current), current, "the composed Time helper must retain the exact cursor");
    let generator = Generator::ColorMatte { color: [0.2, 0.8, 0.2, 1.0] };
    let src = GeneratorSource::new(generator.clone(), 32, 18, rate, Tick(508_032_000_000_000)); // 2000 seconds.
    let mut session = Session::default();
    session.execute("file.newSequence", json!({"fps": 31, "width": 32, "height": 18})).unwrap();
    let item = Arc::make_mut(&mut session.project).add_item(
        "Source with less than one tick per frame",
        Label::Iris,
        ItemKind::Media(Box::new(MediaClip {
            media: MediaRef::Generator(generator),
            info: src.info().clone(),
            interpret: Default::default(),
            mark_in: None,
            mark_out: None,
            markers: vec![],
            offline: false,
            proxy: None,
            identity: None,
        })),
        None,
    );
    assert_eq!(filmcraft_engine::clip_ops::source_view(&session, item).unwrap().rate, rate);
    session.execute("source.open", json!({"item": item.0})).unwrap();
    let mut d = Driver::new(session);
    d.exec("source.setPlayhead", json!({"time": current.0}));
    assert_eq!(d.app().session.state.source_playhead, current, "the public Source seek must accept the exact starting cursor");
    (d, current)
}

#[test]
fn source_toolbar_steps_preserve_zero_tick_frame_duration_cursor() {
    let (mut d, current) = zero_tick_frame_duration_source();
    for button in ["source.transport.src.stepFwd", "source.transport.src.stepBack"] {
        d.click(button);
        assert_eq!(d.app().session.state.source_playhead, current, "{button} must retain the existing zero-duration no-op");
    }
}

#[test]
fn source_menu_steps_preserve_zero_tick_frame_duration_cursor() {
    for explicit_source in [true, false] {
        let (mut d, current) = zero_tick_frame_duration_source();
        d.ok("ui.set", json!({"focused": if explicit_source { "Program" } else { "Source" }}));
        let params = if explicit_source { json!({"monitor": "source"}) } else { json!({}) };
        for command in ["playhead.stepForward", "playhead.stepBack"] {
            d.ok("ui.menu.invoke", json!({"id": command, "params": params.clone()}));
            assert_eq!(d.app().session.state.source_playhead, current, "{command}, explicit Source target: {explicit_source}");
        }
    }
}

#[test]
fn link_media_large_lists_and_long_paths_keep_actions_on_screen() {
    for (width, height) in [(1600.0, 980.0), (1024.0, 768.0), (800.0, 600.0)] {
        let mut s = Session::default();
        s.execute("file.openDemoProject", json!({})).unwrap();
        let mut p = (*s.project).clone();
        let template = p.items.values().find_map(|i| i.as_media()).unwrap().clone();
        for n in 0..100 {
            let mut media = template.clone();
            media.media = MediaRef::File { path: format!("/missing/{}/clip-{n}.mov", "long-project-directory/".repeat(20)) };
            media.offline = true;
            let id = p.add_item(&format!("Missing clip {n}"), Label::Iris, ItemKind::Media(Box::new(media)), None);
            s.offline.missing.push(id);
        }
        s.project = Arc::new(p);
        let mut app = FilmcraftApp::new(s);
        app.ui.link_media = Some(Default::default());
        let mut builder = Harness::builder().with_size(egui::vec2(width, height)).with_max_steps(10_000);
        let snapshots = std::env::var_os("FILMCRAFT_UI_SNAPSHOT_DIR").map(PathBuf::from);
        if snapshots.is_some() {
            builder = builder.wgpu();
        }
        let mut h = builder.build_eframe(move |_| app);
        for _ in 0..8 {
            h.step();
        }
        for id in ["linkMedia.locate", "linkMedia.cancel", "linkMedia.offlineAll", "linkMedia.link"] {
            let r = h.state().auto.find(id).unwrap().rect;
            assert!(r[0] >= 0.0 && r[1] >= 0.0 && r[0] + r[2] <= width && r[1] + r[3] <= height, "{id} at {r:?} outside {width}x{height}");
        }
        if let Some(dir) = snapshots {
            std::fs::create_dir_all(&dir).unwrap();
            h.render().unwrap().save(dir.join(format!("media-long-paths-{width}x{height}.png"))).unwrap();
        }
    }
}

#[test]
fn link_media_dialog_relinks_moved_media() {
    let root = tmp_dir("link");
    let path = moved_project(&root);
    let mut s = Session::default();
    s.execute("file.open", json!({"path": path})).unwrap();
    let mut d = Driver::new(s);
    d.frames(6);
    // the dialog opened by itself, listing both clips; the Project panel marks them
    let rows = d.ids("linkMedia.row.");
    assert_eq!(rows.len(), 2, "{rows:?}");
    assert!(!d.ids("linkMedia.locate").is_empty() && !d.ids("linkMedia.offlineAll").is_empty());
    d.snapshot("media-link-dialog");
    // search the moved folder for the selected clip
    let folder = root.join("Moved").to_string_lossy().into_owned();
    d.app().ui.link_media.as_mut().unwrap().folder = folder;
    d.click("linkMedia.search");
    assert_eq!(d.ids("linkMedia.candidate.").len(), 1);
    d.frames(4);
    d.snapshot("media-link-search");
    d.click("linkMedia.link");
    d.frames(4);
    assert!(d.app().ui.link_media.is_none(), "both clips relinked (the second by folder remap), dialog closed");
    let st = d.exec("media.status", json!({}));
    assert!(st.as_array().unwrap().iter().all(|m| m["status"] == "online"), "{st}");
    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn offline_badges_proxy_toggle_and_dialogs() {
    let root = tmp_dir("badges");
    let path = moved_project(&root);
    let mut s = Session::default();
    s.execute("file.open", json!({"path": path})).unwrap();
    let mut d = Driver::new(s);
    d.frames(4);
    d.click("linkMedia.cancel");
    assert!(d.app().ui.link_media.is_none());
    // the Program monitor shows the offline slate; the project panel marks offline items
    d.exec("playhead.set", json!({"frame": 6}));
    d.frames(30);
    let offline_badges = d.ids("project.item.").into_iter().filter(|i| i.ends_with(".offline")).count();
    assert_eq!(offline_badges, 2, "icon-view offline markers");
    d.snapshot("media-offline-project");
    // relink by folder remap, create proxies through the dialog, toggle them from the monitor
    d.exec("media.autoRelink", json!({"from": root.join("Media").to_string_lossy(), "to": root.join("Moved/Media").to_string_lossy()}));
    let items: Vec<u64> = d.exec("media.status", json!({})).as_array().unwrap().iter().map(|m| m["item"].as_u64().unwrap()).collect();
    d.exec("project.select", json!({"items": items}));
    d.ok("ui.menu.invoke", json!({"id": "media.createProxies"}));
    d.frames(3);
    assert!(d.app().ui.create_proxies.is_some());
    d.snapshot("media-create-proxies");
    d.click("proxies.preset.prores_proxy_quarter");
    let prior_jobs = d.app().session.jobs.len();
    d.click("proxies.ok");
    let proxy_jobs = d.app().session.jobs[prior_jobs..].to_vec();
    assert!(!proxy_jobs.is_empty(), "creating proxies starts a media job");
    // Media jobs share a queue with other UI tests; allow a queued transcode up to 60 seconds.
    for _ in 0..1200 {
        d.frames(1);
        let attached = d.app().session.project.items.values().filter(|i| i.as_media().is_some_and(|m| m.proxy.is_some())).count();
        let finished = proxy_jobs.iter().all(|job| job.result.lock().unwrap_or_else(|e| e.into_inner()).is_some());
        if attached == 2 || finished {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(50));
    }
    let jobs = d.exec("jobs.list", json!({}));
    assert_eq!(d.app().session.project.items.values().filter(|i| i.as_media().is_some_and(|m| m.proxy.is_some())).count(), 2, "proxies attached; jobs: {jobs}");
    d.click("program.transport.media.toggleProxies");
    assert!(d.app().session.prefs.media.enable_proxies);
    assert_eq!(d.ids("project.item.").into_iter().filter(|i| i.ends_with(".proxy")).count(), 2, "proxy badges");
    d.frames(20);
    d.snapshot("media-proxies-on");
    // Project Manager dialog: calculate the size estimate
    d.ok("ui.menu.invoke", json!({"id": "file.projectManager"}));
    d.frames(2);
    d.app().ui.project_manager.as_mut().unwrap().destination = root.join("Collected").to_string_lossy().into_owned();
    d.click("pm.calculate");
    let est = d.app().ui.project_manager.as_ref().unwrap().estimate;
    assert!(est.is_some_and(|(a, b, n)| a > 0 && b == a && n == 2), "{est:?}");
    d.snapshot("media-project-manager");
    d.click("pm.ok");
    assert!(d.app().ui.project_manager.is_none());
    let _ = std::fs::remove_dir_all(&root);
}

/// #111: Link Media ▸ Locate… relinks the selected clip to the chosen file instead of importing it,
/// both with a host that returns the path and with one (the web) that runs the hint's command later.
#[test]
fn locate_relinks_instead_of_importing() {
    let root = tmp_dir("locate");
    let path = moved_project(&root);
    let mut s = Session::default();
    s.execute("file.open", json!({"path": path})).unwrap();
    let mut d = Driver::new(s);
    d.frames(6);
    let items = d.app().session.project.items.len();
    let imported = Arc::new(std::sync::Mutex::new(0));
    let n = imported.clone();
    d.app().hooks.pick_files = Some(Box::new(move |_| {
        *n.lock().unwrap() += 1;
        vec![]
    }));
    // an async host: nothing comes back now, the hint says what to run later
    let hints = Arc::new(std::sync::Mutex::new(Vec::new()));
    let h = hints.clone();
    d.app().hooks.pick_file_for_relink = Some(Box::new(move |_, hint| {
        h.lock().unwrap().push(hint);
        None
    }));
    d.click("linkMedia.locate");
    let hint = hints.lock().unwrap().pop().flatten().expect("the picker got a hint");
    assert_eq!(hint.command, "media.relink");
    let item = hint.params["item"].as_u64().expect("the hint names the clip");
    assert!(hint.params["match"].is_object(), "and the dialog's match options: {}", hint.params);
    // what the web host does once the user has chosen
    let file = root.join("Moved/Media/Harbour.mov").to_string_lossy().into_owned();
    let mut p = hint.params.clone();
    p["path"] = json!(file);
    d.exec(&hint.command, p);
    // a host that returns the path relinks the other clip from the dialog itself
    let other = root.join("Moved/Media/Night.mov").to_string_lossy().into_owned();
    d.app().hooks.pick_file_for_relink = Some(Box::new(move |_, _| Some(other.clone())));
    if d.app().ui.link_media.is_some() {
        d.click("linkMedia.locate");
        d.frames(4);
    }
    assert_eq!(*imported.lock().unwrap(), 0, "Locate… never goes through the import picker");
    assert_eq!(d.app().session.project.items.len(), items, "no new project item");
    let st = d.exec("media.status", json!({}));
    assert!(st.as_array().unwrap().iter().all(|m| m["status"] == "online"), "item {item}: {st}");
    let _ = std::fs::remove_dir_all(&root);
}

/// [`make_movie`]'s ProRes file with its sample entry retyped `icod`: an Apple Intermediate Codec
/// movie as far as the demuxer can tell, which no FilmCraft decoder reads (#3646).
fn aic_movie(path: &Path) {
    make_movie(path, DemoScene::OceanSunset, 64, 32, 2);
    let mut b = std::fs::read(path).unwrap();
    // stsd (ISO/IEC 14496-12 §8.5.2): type, version/flags, entry_count, then the first entry's
    // size and type; the video track's entry is the ProRes one (`ap..`)
    let k =
        (0..b.len().saturating_sub(20)).filter(|&k| &b[k..k + 4] == b"stsd").map(|k| k + 16).find(|&k| b[k..k + 2] == *b"ap").expect("a ProRes sample entry");
    b[k..k + 4].copy_from_slice(b"icod");
    std::fs::write(path, b).unwrap();
}

/// #3646: a movie in a codec FilmCraft cannot decode (Apple Intermediate Codec) imports under the
/// codec's name, and its Unreadable badge says why on hover, in Icon view and in List view, where a
/// name longer than the Name column is cut short with "…" to keep the badge in view and shows
/// in full on hover.
#[test]
fn unreadable_badge_says_why_on_hover() {
    let root = tmp_dir("aic");
    // wider than the List view's Name column
    let file = root.join("Holiday on the coast with the whole family, summer 2010.mov");
    aic_movie(&file);
    let mut s = Session::default();
    let r = s.execute("file.import", json!({"paths": [file.to_string_lossy()]})).unwrap();
    let item = r["items"][0].as_u64().expect("imported item");
    let id = filmcraft_engine::project::ItemId(item);
    let codec = s.project.item(id).and_then(|i| i.as_media()).and_then(|m| m.info.video.as_ref()).map(|v| v.codec.clone());
    assert_eq!(codec.as_deref(), Some("Apple Intermediate Codec"));
    let mut d = Driver::new(s);
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    d.ok("ui.set", json!({"focused": "Project"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.frames(3);
    let why = "no decoder for Apple Intermediate Codec video";
    let badge = format!("project.item.{item}.offline");
    for view in ["icon", "list"] {
        d.exec("project.view.set", json!({"view": view}));
        // a thumbnail decode fails, and the media pool marks the item unreadable
        let t0 = std::time::Instant::now();
        while !d.ids(&badge).contains(&badge) {
            assert!(t0.elapsed().as_secs() < 120, "{view} view: no offline badge on {item}");
            std::thread::sleep(std::time::Duration::from_millis(5));
            d.frames(1);
        }
        assert_eq!(d.app().session.media.offline_status(id).map(|st| st.error).as_deref(), Some(why));
        // the tooltip is a node of its own, with the reason as its label
        let shown = |d: &Driver| d.harness.query_all_by_label(why).count();
        let before = shown(&d);
        d.ok("ui.move", json!({"id": badge, "fx": 0.5, "fy": 0.5}));
        for _ in 0..60 {
            if shown(&d) > before {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(10));
            d.frames(1);
        }
        assert!(shown(&d) > before, "{view} view: hovering the Unreadable badge shows why");
        d.snapshot(&format!("media-unreadable-{view}"));
        if view == "list" {
            // the cut name ends just before the badge, and shows in full on hover
            let e = d.ok("ui.elements", json!({"prefix": badge}));
            let r = &e.as_array().unwrap().iter().find(|e| e["id"] == badge.as_str()).expect("the badge")["rect"];
            let (x, y) = (r[0].as_f64().unwrap() - 30.0, r[1].as_f64().unwrap() + r[3].as_f64().unwrap() / 2.0);
            let name = file.file_name().unwrap().to_string_lossy().into_owned();
            let full = |d: &Driver| d.harness.query_all_by_label(&name).count();
            let before = full(&d);
            d.ok("ui.move", json!({"x": x, "y": y}));
            for _ in 0..60 {
                if full(&d) > before {
                    break;
                }
                std::thread::sleep(std::time::Duration::from_millis(10));
                d.frames(1);
            }
            assert!(full(&d) > before, "hovering a List-view name cut short shows it in full");
        }
        // off the badge before the next view draws its own
        d.ok("ui.move", json!({"id": "panel.Project", "fx": 0.5, "fy": 0.95}));
        d.frames(3);
    }
    let _ = std::fs::remove_dir_all(&root);
}