filmcraft/crates/engine/tests/marker_properties.rs

use filmcraft_engine::Session;
use filmcraft_project::{HexColor, Label};
use serde_json::json;

#[test]
fn review_null_author_is_omitted_for_creation_and_preserves_existing_author() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    for cmd in ["markers.add", "markers.addRange"] {
        let id = s.execute(cmd, json!({"frame":0,"durationFrames":10,"author":null})).unwrap()["marker"].as_u64().unwrap();
        s.execute("markers.edit", json!({"marker":id,"author":"Editor"})).unwrap();
        let before = s.project.to_json();
        let history = s.history.undo.len();
        s.execute("markers.edit", json!({"marker":id,"author":null,"name":"Updated"})).unwrap();
        let marker = s.active_sequence().unwrap().markers.iter().find(|m| m.id.0 == id).unwrap();
        assert_eq!(marker.author, "Editor");
        assert_eq!(marker.name, "Updated");
        assert_eq!(s.history.undo.len(), history + 1);
        s.execute("edit.undo", json!({})).unwrap();
        assert_eq!(s.project.to_json(), before);
    }
}

#[test]
fn web_link_url_is_separate_from_notes_atomic_persistent_and_optional_in_old_projects() {
    use filmcraft_project::MarkerKind;
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    let id = s.execute("markers.add", json!({"frame":0,"name":"Review","comment":"Use take two"})).unwrap()["marker"].as_u64().unwrap();
    let sequence = s.state.active_sequence.unwrap();
    let before = s.project.to_json();
    let history = s.history.undo.len();
    let url = "https://example.com/review?take=2#notes";
    s.execute("markers.edit", json!({"marker":id,"kind":"webLink","url":format!(" {url} "),"comment":"Awaiting approval"})).unwrap();
    let marker = s.active_sequence().unwrap().markers[0].clone();
    assert_eq!((&*marker.url, &*marker.comment, marker.kind), (url, "Awaiting approval", MarkerKind::WebLink));
    assert_eq!(s.history.undo.len(), history + 1);
    let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
    assert_eq!(loaded.project.sequence(sequence).unwrap().markers[0], marker);
    assert_eq!(s.execute("sequence.inspect", json!({})).unwrap()["markers"][0]["url"], url);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
    s.execute("edit.redo", json!({})).unwrap();
    s.execute("markers.edit", json!({"marker":id,"kind":"comment","url":null})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].url, url);
    s.execute("markers.edit", json!({"marker":id,"kind":"webLink"})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].url, url);
    let mut legacy: serde_json::Value = serde_json::from_slice(&filmcraft_format::encode(&s.project, false)).unwrap();
    legacy["schema_version"] = json!(16);
    fn remove_urls(value: &mut serde_json::Value) {
        match value {
            serde_json::Value::Object(map) => {
                map.remove("url");
                for value in map.values_mut() {
                    remove_urls(value);
                }
            }
            serde_json::Value::Array(values) => {
                for value in values {
                    remove_urls(value);
                }
            }
            _ => {}
        }
    }
    remove_urls(&mut legacy);
    let loaded = filmcraft_format::decode(&serde_json::to_vec(&legacy).unwrap()).unwrap();
    assert!(loaded.migrated());
    assert!(loaded.project.sequence(sequence).unwrap().markers[0].url.is_empty());
    for invalid in [
        json!("file:///tmp/a"),
        json!("javascript:alert(1)"),
        json!("https://user:pass@example.com"),
        json!("https://a\nb"),
        json!("https://"),
        json!("https:example.com"),
        json!("relative/path"),
        json!(42),
        json!({}),
        json!(["https://example.com"]),
        json!("x".repeat(8193)),
    ] {
        let before = s.project.to_json();
        let history = s.history.undo.len();
        assert!(s.execute("markers.edit", json!({"marker":id,"url":invalid,"name":"Must not change"})).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
    s.execute("markers.edit", json!({"marker":id,"url":""})).unwrap();
    assert!(s.active_sequence().unwrap().markers[0].url.is_empty());
    assert_eq!(s.active_sequence().unwrap().markers[0].comment, "Awaiting approval");
}

#[test]
fn review_close_project_renews_runtime_identity() {
    let mut session = Session::default();
    session.execute("file.newSequence", json!({})).unwrap();
    let original = session.project_instance.clone();
    assert!(session.execute("file.closeProject", json!({})).is_err());
    assert!(std::sync::Arc::ptr_eq(&original, &session.project_instance), "a rejected close must retain the live project's identity");
    session.execute("file.closeProject", json!({"force":true})).unwrap();
    assert!(!std::sync::Arc::ptr_eq(&original, &session.project_instance));
    assert!(session.project.items.is_empty());
    assert!(!session.history.can_undo());
}

#[test]
fn marker_kinds_edit_atomically_and_reject_invalid_values() {
    use filmcraft_project::MarkerKind;
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    let marker = s.execute("markers.add", json!({"frame":0,"name":"Original"})).unwrap()["marker"].as_u64().unwrap();
    for (value, expected) in [
        ("chapter", MarkerKind::Chapter),
        ("segmentation", MarkerKind::Segmentation),
        ("webLink", MarkerKind::WebLink),
        ("flashCue", MarkerKind::FlashCue),
        ("comment", MarkerKind::Comment),
    ] {
        let before = s.project.to_json();
        let history = s.history.undo.len();
        s.execute("markers.edit", json!({"marker":marker,"kind":value,"name":"Changed","comment":"Together"})).unwrap();
        assert_eq!(s.active_sequence().unwrap().markers[0].kind, expected);
        assert_eq!(s.history.undo.len(), history + 1);
        s.execute("edit.undo", json!({})).unwrap();
        assert_eq!(s.project.to_json(), before);
        s.execute("edit.redo", json!({})).unwrap();
        assert_eq!(s.active_sequence().unwrap().markers[0].kind, expected);
    }
    for kind in [json!("unknown"), json!(true), json!(42), json!([]), json!({})] {
        let before = s.project.to_json();
        let history = s.history.undo.len();
        assert!(s.execute("markers.edit", json!({"marker":marker,"kind":kind,"name":"Must not change"})).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
}

#[test]
fn custom_marker_properties_survive_undo_and_project_reopen() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({"name":"Review"})).unwrap();
    let id = s.execute("markers.add", json!({"frame":0,"name":"Note","author":"BENJI","color":"#ff80c0"})).unwrap()["marker"].as_u64().unwrap();
    let seq = s.state.active_sequence.unwrap();
    let original = s.active_sequence().unwrap().markers[0].clone();
    assert_eq!(original.rgb(), [255, 128, 192]);
    assert_eq!(original.color_value(), "#FF80C0");
    assert_eq!(original.author, "BENJI");
    let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
    assert_eq!(loaded.project.sequence(seq).unwrap().markers[0], original);
    s.execute("markers.edit", json!({"marker":id,"color":"White"})).unwrap_err();
    s.execute("markers.edit", json!({"marker":id,"comment":"Keep"})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].custom_color, original.custom_color);
    s.execute("markers.edit", json!({"marker":id,"color":"Blue","author":""})).unwrap();
    let marker = &s.active_sequence().unwrap().markers[0];
    assert_eq!(marker.color, Label::Blue);
    assert_eq!(marker.custom_color, None);
    assert_eq!(marker.author, "");
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].custom_color, HexColor::parse("#FF80C0"));
    assert_eq!(s.active_sequence().unwrap().markers[0].author, "BENJI");
    s.execute("edit.redo", json!({})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].custom_color, None);
    let inspected = s.execute("sequence.inspect", json!({})).unwrap();
    assert_eq!(inspected["markers"][0]["author"], "");
    assert_eq!(inspected["markers"][0]["color"], "Blue");
}

#[test]
fn invalid_marker_properties_leave_project_and_undo_unchanged() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    let id = s.execute("markers.add", json!({})).unwrap()["marker"].as_u64().unwrap();
    for change in [
        json!({"color":"#123"}),
        json!({"color":"#00000000"}),
        json!({"color":"#€aaaa"}),
        json!({"color":[0,0,0]}),
        json!({"author":true}),
        json!({"author":"a\nb"}),
        json!({"author":"a".repeat(1025)}),
    ] {
        let before = s.project.to_json();
        let history = s.history.undo.len();
        let mut params = change;
        params["marker"] = json!(id);
        assert!(s.execute("markers.edit", params).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
}

#[test]
fn all_marker_creation_commands_accept_hex_and_author() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    for cmd in ["markers.add", "markers.addRange", "markers.addChapter", "markers.addFlashCue"] {
        s.execute(cmd, json!({"name":"Cue", "durationFrames":10,"color":"#FFFFFF","author":"Editor"})).unwrap();
        let marker = s.active_sequence().unwrap().markers.last().unwrap();
        assert_eq!(marker.rgb(), [255; 3], "{cmd}");
        assert_eq!(marker.author, "Editor", "{cmd}");
    }
}

#[test]
fn custom_palette_is_project_local_bounded_and_undoable() {
    let mut s = Session::default();
    let before = s.project.to_json();
    for invalid in [json!("Rose"), json!("#123"), json!(true), json!(42)] {
        assert!(s.execute("colors.addCustom", json!({"color":invalid})).is_err());
        assert_eq!(s.project.to_json(), before);
    }
    s.execute("colors.addCustom", json!({"color":"#ff80c0"})).unwrap();
    let history = s.history.undo.len();
    s.execute("colors.addCustom", json!({"color":"#FF80C0"})).unwrap();
    assert_eq!(s.history.undo.len(), history, "duplicates do not create edits");
    let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
    assert_eq!(loaded.project.custom_colors, s.project.custom_colors);
    assert!(Session::default().project.custom_colors.is_empty());
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
    s.execute("edit.redo", json!({})).unwrap();
    for value in 0..63 {
        s.execute("colors.addCustom", json!({"color":format!("#{value:06X}")})).unwrap();
    }
    assert_eq!(s.project.custom_colors.len(), 64);
    let full = s.project.to_json();
    assert!(s.execute("colors.addCustom", json!({"color":"#FFFFFF"})).is_err());
    assert_eq!(s.project.to_json(), full);
}

#[test]
fn custom_clip_colors_share_palette_and_survive_save_preset_switch_and_undo() {
    let mut s = Session::default();
    s.execute("file.openDemoProject", json!({})).unwrap();
    let seq = s.state.active_sequence.unwrap();
    let clip = s.active_sequence().unwrap().video_tracks[0].items[0].clone();
    let before = s.project.to_json();
    let history = s.history.undo.len();
    s.execute("edit.label", json!({"clips":[clip.id.0],"label":"#12abcd","saveColor":true})).unwrap();
    let color = HexColor::parse("#12ABCD");
    assert_eq!(s.active_sequence().unwrap().find_item(clip.id).unwrap().1.custom_label_color, color);
    assert_eq!(s.project.custom_colors, vec![color.unwrap()]);
    s.execute("sequence.linkedSelection", json!({"on":false})).unwrap();
    s.execute("timeline.select", json!({"clips":[clip.id.0]})).unwrap();
    s.execute("edit.selectLabelGroup", json!({})).unwrap();
    assert_eq!(s.state.selection, vec![clip.id]);
    assert_eq!(s.history.undo.len(), history + 1);
    let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
    assert_eq!(loaded.project.sequence(seq).unwrap().find_item(clip.id).unwrap().1.custom_label_color, color);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
    s.execute("edit.redo", json!({})).unwrap();
    s.execute("edit.label.violet", json!({"clips":[clip.id.0]})).unwrap();
    assert_eq!(s.active_sequence().unwrap().find_item(clip.id).unwrap().1.custom_label_color, None);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.active_sequence().unwrap().find_item(clip.id).unwrap().1.custom_label_color, color);
    s.execute("edit.label", json!({"items":[clip.item.0],"label":"#12ABCD"})).unwrap();
    let mut project = (*s.project).clone();
    let created = project
        .make_track_item(
            clip.item,
            filmcraft_project::TrackKind::Video,
            clip.start,
            filmcraft_time::TimeRange::new(clip.source_in, clip.duration),
            s.sequence_rate(),
        )
        .unwrap();
    assert_eq!(created.custom_label_color, color);
    s.execute("project.select", json!({"items":[clip.item.0]})).unwrap();
    let copy = s.execute("edit.duplicate", json!({})).unwrap()["items"][0].as_u64().unwrap();
    assert_eq!(s.project.item(filmcraft_project::ItemId(copy)).unwrap().custom_label_color, color);
    let before = s.project.to_json();
    for params in [json!({"label":"#XYZXYZ"}), json!({"label":"#FFFFFF","clips":[-1]}), json!({"label":"#FFFFFF","clips":[u64::MAX],"saveColor":true})] {
        assert!(s.execute("edit.label", params).is_err());
        assert_eq!(s.project.to_json(), before);
    }
}

#[test]
fn metadata_label_edits_use_the_effective_color_and_clear_custom_overrides() {
    let mut s = Session::default();
    s.execute("file.openDemoProject", json!({})).unwrap();
    let item = s.active_sequence().unwrap().video_tracks[0].items[0].item;
    let preset = s.project.item(item).unwrap().label;
    s.execute("edit.label", json!({"items":[item.0],"label":"#123456"})).unwrap();
    let metadata = s.execute("metadata.get", json!({"item":item.0})).unwrap();
    assert_eq!(metadata["fields"].as_array().unwrap().iter().find(|f| f["name"] == "Label").unwrap()["value"], "#123456");
    let result = s.execute("metadata.set", json!({"item":item.0,"field":"Label","value":preset.name()})).unwrap();
    assert_eq!(result["changed"], true);
    assert_eq!(s.project.item(item).unwrap().custom_label_color, None);
    s.execute("edit.undo", json!({})).unwrap();
    let result = s.execute("metadata.set", json!({"item":item.0,"field":"Label","value":"#123456"})).unwrap();
    assert_eq!(result["changed"], false);
    assert_eq!(result["label"], "#123456");
    s.execute("metadata.set", json!({"item":item.0,"field":"Label","value":"#abcdef"})).unwrap();
    assert_eq!(s.project.item(item).unwrap().label_value(), "#ABCDEF");
    s.execute("metadata.set", json!({"item":item.0,"field":"Label","value":"Red"})).unwrap();
    assert_eq!(s.project.item(item).unwrap().label, Label::Rose);
    assert_eq!(s.project.item(item).unwrap().custom_label_color, None);
}

#[test]
fn marker_and_clip_aliases_resolve_to_the_same_unchanged_presets() {
    let mut s = Session::default();
    s.execute("file.openDemoProject", json!({})).unwrap();
    let clip = s.active_sequence().unwrap().video_tracks[0].items[0].id;
    for (alias, preset) in Label::COLOR_ALIASES {
        let id = s.execute("markers.add", json!({"color":alias.to_lowercase()})).unwrap()["marker"].as_u64().unwrap();
        let marker = s.active_sequence().unwrap().markers.iter().find(|m| m.id.0 == id).unwrap();
        assert_eq!(marker.color, preset);
        assert_eq!(marker.rgb(), preset.rgb());
        s.execute("edit.label", json!({"clips":[clip.0],"label":alias})).unwrap();
        assert_eq!(s.active_sequence().unwrap().find_item(clip).unwrap().1.label, preset);
        s.execute("markers.filterColors", json!({"color":alias,"visible":false})).unwrap();
        assert!(s.state.hidden_marker_colors.contains(&preset));
    }
    assert_eq!(Label::Rose.rgb(), [0x80, 0x18, 0x36]);
    assert_eq!(Label::Mango.rgb(), [0x80, 0x3f, 0x17]);
    assert_eq!(Label::Teal.rgb(), [0x1f, 0x4d, 0x45]);
}

#[test]
fn marker_time_edits_are_sorted_exact_and_reject_hostile_ranges_atomically() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    let first = s.execute("markers.add", json!({"frame":10})).unwrap()["marker"].as_u64().unwrap();
    let second = s.execute("markers.add", json!({"frame":20})).unwrap()["marker"].as_u64().unwrap();
    let rate = s.sequence_rate();
    s.execute("markers.edit", json!({"marker":first,"frame":30,"durationFrames":5})).unwrap();
    let markers = &s.active_sequence().unwrap().markers;
    assert_eq!(markers[0].id.0, second);
    assert_eq!(markers[1].start, rate.tick_of(30));
    assert_eq!(markers[1].duration, rate.tick_of(5));
    for change in [
        json!({"frame":-1}),
        json!({"frame":i64::MAX}),
        json!({"durationFrames":-1}),
        json!({"durationFrames":"2"}),
        json!({"durationFrames":1.5}),
        json!({"durationFrames":i64::MAX}),
        json!({"time":i64::MAX}),
        json!({"time":true}),
        json!({"frame":1,"time":0}),
        json!({"name":false}),
    ] {
        let before = s.project.to_json();
        let history = s.history.undo.len();
        let mut p = change;
        p["marker"] = json!(first);
        assert!(s.execute("markers.edit", p).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
    s.execute("markers.edit", json!({"marker":first,"durationFrames":0})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[1].duration, filmcraft_time::Tick::ZERO);
    s.execute("markers.edit", json!({"marker":first,"time":123})).unwrap();
    s.execute("markers.edit", json!({"marker":first,"author":"Preserve subframes"})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].start.0, 123);
}

#[test]
fn bulk_marker_changes_are_owner_scoped_atomic_and_one_undo() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    let owner = s.state.active_sequence.unwrap();
    let a = s.execute("markers.add", json!({"frame":10})).unwrap()["marker"].as_u64().unwrap();
    let b = s.execute("markers.add", json!({"frame":10})).unwrap()["marker"].as_u64().unwrap();
    s.execute("file.newSequence", json!({})).unwrap();
    let before = s.project.to_json();
    let history = s.history.undo.len();
    s.execute("markers.edit", json!({"sequence":owner.0,"markers":[a,b],"color":"#123456"})).unwrap();
    assert_eq!(s.history.undo.len(), history + 1);
    assert!(s.project.sequence(owner).unwrap().markers.iter().all(|m| m.rgb() == [0x12, 0x34, 0x56]));
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
    for params in [
        json!({"markers":[a,u64::MAX]}),
        json!({"markers":[]}),
        json!({"marker":a,"markers":[b]}),
        json!({"markers":[-1]}),
        json!({"marker":a,"target":"nonsense"}),
    ] {
        let mut p = params;
        p["sequence"] = json!(owner.0);
        for cmd in ["markers.edit", "markers.delete"] {
            assert!(s.execute(cmd, p.clone()).is_err());
            assert_eq!(s.project.to_json(), before);
            assert_eq!(s.history.undo.len(), history);
        }
    }
    s.execute("markers.delete", json!({"sequence":owner.0,"marker":a})).unwrap();
    assert_eq!(s.project.sequence(owner).unwrap().markers.iter().map(|m| m.id.0).collect::<Vec<_>>(), vec![b]);
    s.execute("edit.undo", json!({})).unwrap();
    s.execute("markers.delete", json!({"sequence":owner.0,"markers":[a,b]})).unwrap();
    assert_eq!(s.history.undo.len(), history + 1);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
}

#[test]
fn source_marker_edits_keep_their_owner_and_enforce_bounds() {
    let mut s = Session::default();
    s.execute("file.openDemoProject", json!({})).unwrap();
    let source = filmcraft_project::ItemId(5);
    s.execute("source.open", json!({"item":source.0})).unwrap();
    let marker = s.execute("markers.add", json!({"target":"source","time":0})).unwrap()["marker"].as_u64().unwrap();
    let view = filmcraft_engine::clip_ops::source_view(&s, source).unwrap();
    let other = s.project.items.values().find(|i| i.as_media().is_some() && i.id != source).unwrap().id;
    s.execute("source.open", json!({"item":other.0})).unwrap();
    s.execute(
        "markers.edit",
        json!({"target":"source","item":source.0,"marker":marker,"frame":1,"durationFrames":2,"kind":"webLink","url":"https://example.com/source"}),
    )
    .unwrap();
    assert_eq!(filmcraft_engine::clip_ops::source_view(&s, source).unwrap().markers[0].start, view.rate.tick_of(1));
    assert_eq!(filmcraft_engine::clip_ops::source_view(&s, source).unwrap().markers[0].kind, filmcraft_project::MarkerKind::WebLink);
    assert_eq!(filmcraft_engine::clip_ops::source_view(&s, source).unwrap().markers[0].url, "https://example.com/source");
    let before = s.project.to_json();
    let history = s.history.undo.len();
    for change in [json!({"time":view.end.0}), json!({"time":view.end.0-1,"durationFrames":2}), json!({"durationFrames":i64::MAX}), json!({"time":-1})] {
        let mut p = change;
        p["target"] = json!("source");
        p["item"] = json!(source.0);
        p["marker"] = json!(marker);
        assert!(s.execute("markers.edit", p).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
    assert!(s.execute("markers.delete", json!({"target":"source","marker":marker})).is_err());
    s.execute("markers.delete", json!({"target":"source","item":source.0,"marker":marker})).unwrap();
    assert!(filmcraft_engine::clip_ops::source_view(&s, source).unwrap().markers.is_empty());
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
}

#[test]
fn named_palette_management_preserves_assignments_and_roundtrips() {
    let mut s = Session::default();
    s.execute("file.newSequence", json!({})).unwrap();
    s.execute("markers.add", json!({"color":"#123456"})).unwrap();
    s.execute("colors.addCustom", json!({"color":"#123456","name":"Review"})).unwrap();
    let before = s.project.to_json();
    s.execute("colors.updateCustom", json!({"color":"#123456","replacement":"#654321","name":"Approved"})).unwrap();
    assert_eq!(s.active_sequence().unwrap().markers[0].color_value(), "#123456");
    let new = HexColor::parse("654321").unwrap();
    assert_eq!(s.project.custom_color_names[&new], "Approved");
    let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
    assert_eq!(loaded.project.custom_color_names, s.project.custom_color_names);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
    for (cmd, p) in [
        ("colors.updateCustom", json!({"color":"#123456","replacement":"oops"})),
        ("colors.updateCustom", json!({"color":"#FFFFFF"})),
        ("colors.addCustom", json!({"color":"#FFFFFF","name":"bad\nname"})),
        ("colors.removeCustom", json!({"color":true})),
    ] {
        let history = s.history.undo.len();
        assert!(s.execute(cmd, p).is_err());
        assert_eq!(s.project.to_json(), before);
        assert_eq!(s.history.undo.len(), history);
    }
    s.execute("colors.removeCustom", json!({"color":"#123456"})).unwrap();
    assert!(s.project.custom_colors.is_empty());
    assert!(s.project.custom_color_names.is_empty());
    assert_eq!(s.active_sequence().unwrap().markers[0].color_value(), "#123456");
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
}

#[test]
fn subclip_marker_edits_share_parent_storage_but_obey_view_bounds() {
    let mut s = Session::default();
    s.execute("file.openDemoProject", json!({})).unwrap();
    s.execute("source.open", json!({"item":5})).unwrap();
    let rate = filmcraft_engine::clip_ops::source_view(&s, filmcraft_project::ItemId(5)).unwrap().rate;
    let inside = s.execute("markers.add", json!({"target":"source","time":rate.tick_of(15).0})).unwrap()["marker"].as_u64().unwrap();
    let outside = s.execute("markers.add", json!({"target":"source","time":rate.tick_of(5).0})).unwrap()["marker"].as_u64().unwrap();
    let sub = s.execute("clip.makeSubclip", json!({"item":5,"startFrame":10,"endFrame":30})).unwrap()["item"].as_u64().unwrap();
    s.execute("markers.edit", json!({"target":"source","item":sub,"marker":inside,"frame":20,"durationFrames":10,"author":"Shared"})).unwrap();
    let parent = filmcraft_engine::clip_ops::source_view(&s, filmcraft_project::ItemId(5)).unwrap();
    assert_eq!(parent.markers.iter().find(|m| m.id.0 == inside).unwrap().author, "Shared");
    let before = s.project.to_json();
    for p in [
        json!({"marker":outside,"name":"Hidden"}),
        json!({"marker":inside,"frame":5}),
        json!({"marker":inside,"durationFrames":11}),
        json!({"markers":[inside,outside],"color":"Blue"}),
    ] {
        let mut p = p;
        p["target"] = json!("source");
        p["item"] = json!(sub);
        assert!(s.execute("markers.edit", p).is_err());
        assert_eq!(s.project.to_json(), before);
    }
    s.execute("markers.delete", json!({"target":"source","item":sub,"marker":inside})).unwrap();
    assert_eq!(filmcraft_engine::clip_ops::source_view(&s, filmcraft_project::ItemId(5)).unwrap().markers.len(), 1);
    s.execute("edit.undo", json!({})).unwrap();
    assert_eq!(s.project.to_json(), before);
}

#[test]
fn custom_marker_filters_share_show_all_and_reject_invalid_updates() {
    let mut s = Session::default();
    s.execute("markers.filterColors", json!({"hidden":["Red","#123456"]})).unwrap();
    assert!(s.state.hidden_marker_colors.contains(&Label::Rose));
    assert_eq!(s.state.hidden_custom_marker_colors, vec![HexColor::parse("123456").unwrap()]);
    let before = serde_json::to_value(&s.state).unwrap();
    for p in [json!({"hidden":["Blue","bad"]}), json!({"hidden":true}), json!({"color":"#123456","visible":"false"})] {
        assert!(s.execute("markers.filterColors", p).is_err());
        assert_eq!(serde_json::to_value(&s.state).unwrap(), before);
    }
    s.execute("markers.showAllMarkerColors", json!({})).unwrap();
    assert!(s.state.hidden_marker_colors.is_empty());
    assert!(s.state.hidden_custom_marker_colors.is_empty());
    s.execute("markers.filterColors", json!({"color":"#123456","visible":false})).unwrap();
    assert!(s.is_enabled("markers.showAllMarkerColors"));
    s.execute("markers.showAllMarkerColors", json!({})).unwrap();
    assert!(s.state.hidden_custom_marker_colors.is_empty());
}