//! Overrides on and inside nested instances across swaps, variant switches, main updates, detach
//! and copy/paste.

use crate::Session;
use crate::components::tests::{button, copy_of, ex, fill, healthy, idv, kids, node};
use crate::components::*;
use figcraft_doc::*;
use serde_json::json;

/// A 24×24 icon component at (`x`, 300) with one 20×20 rectangle named `layer`.
fn icon(s: &mut Session, x: f64, name: &str, layer: &str) -> NodeId {
    let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 300, "width": 24, "height": 24, "name": name})));
    ex(s, "shape.rectangle", json!({"x": 2, "y": 2, "width": 20, "height": 20, "parent": f, "props": {"name": layer, "fill": "#111111"}}));
    idv(&ex(s, "component.create", json!({"ids": [f]})))
}

fn main_of(s: &Session, id: NodeId) -> NodeId {
    match node(s, id).kind {
        NodeKind::Instance { component, .. } => component,
        _ => panic!("{id} is not an instance"),
    }
}

#[test]
fn swapping_a_nested_instance_keeps_overrides_on_matching_layers() {
    let mut s = Session::new();
    let (_icon, shape, button, nested) = button(&mut s);
    let other = icon(&mut s, 200.0, "Other", "Shape");
    let unrelated = icon(&mut s, 300.0, "Unrelated", "Glyph");
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    let inested = copy_of(&s, i, nested);
    let ishape = kids(&s, inested)[0];
    ex(&mut s, "node.set", json!({"id": ishape, "props": {"fill": "#ff00ff", "opacity": 0.5}}));
    // A main with a same-named layer: the overrides carry over.
    ex(&mut s, "instance.swap", json!({"ids": [inested], "component": other}));
    healthy(&s);
    let ishape = kids(&s, inested)[0];
    assert_eq!(main_of(&s, inested), other);
    assert_eq!(fill(&s, ishape), "FF00FF");
    assert_eq!(node(&s, ishape).opacity, 0.5);
    assert!(node(&s, ishape).overrides.contains("fills"));
    // ... and survive edits of the outer main and of the swapped-in main.
    ex(&mut s, "node.set", json!({"id": button, "props": {"fill": "#00ff00"}}));
    let other_shape = kids(&s, other)[0];
    ex(&mut s, "node.set", json!({"id": other_shape, "props": {"cornerRadius": 5, "fill": "#222222"}}));
    healthy(&s);
    let ishape = kids(&s, copy_of(&s, i, nested))[0];
    assert_eq!(fill(&s, ishape), "FF00FF");
    assert_eq!(node(&s, ishape).corners.radii, [5.0; 4]);
    // No matching layer: the overrides go.
    ex(&mut s, "instance.swap", json!({"ids": [inested], "component": unrelated}));
    healthy(&s);
    assert_eq!(fill(&s, kids(&s, inested)[0]), "111111");
    // Back to the original: it shows its main again.
    ex(&mut s, "component.resetOverride", json!({"id": inested, "group": "component"}));
    healthy(&s);
    assert_eq!(fill(&s, kids(&s, inested)[0]), fill(&s, copy_of(&s, nested, shape)));
}

#[test]
fn variant_switch_keeps_nested_overrides_and_swaps() {
    let mut s = Session::new();
    let ic = icon(&mut s, 0.0, "Icon", "Shape");
    let star = icon(&mut s, 100.0, "Star", "Shape");
    let mut variants = Vec::new();
    for (k, state) in ["Default", "Hover"].iter().enumerate() {
        let f =
            idv(&ex(&mut s, "frame.create", json!({"x": k as f64 * 200.0, "y": 0, "width": 120, "height": 40, "name": format!("State={state}")})));
        ex(
            &mut s,
            "shape.rectangle",
            json!({"x": 0, "y": 0, "width": 120, "height": 40, "parent": f, "props": {"name": "Bg", "fill": if k == 0 { "#ffffff" } else { "#eeeeee" }}}),
        );
        ex(&mut s, "instance.create", json!({"component": ic, "x": 8, "y": 8, "parent": f}));
        variants.push(idv(&ex(&mut s, "component.create", json!({"ids": [f]}))));
    }
    let set = idv(&ex(&mut s, "component.combineVariants", json!({"ids": variants.clone()})));
    let i = idv(&ex(&mut s, "instance.create", json!({"component": set, "x": 0, "y": 200})));
    let inested = kids(&s, i)[1];
    let ishape = kids(&s, inested)[0];
    ex(&mut s, "node.set", json!({"id": ishape, "props": {"fill": "#ff8800"}}));
    ex(&mut s, "node.set", json!({"id": inested, "props": {"opacity": 0.4}}));
    ex(&mut s, "instance.setProperties", json!({"ids": [i], "properties": {"State": "Hover"}}));
    healthy(&s);
    let inested = kids(&s, i)[1];
    assert_eq!(fill(&s, kids(&s, i)[0]), "EEEEEE", "the new variant shows");
    assert_eq!(fill(&s, kids(&s, inested)[0]), "FF8800", "override inside the nested instance kept");
    assert_eq!(node(&s, inested).opacity, 0.4, "override on the nested instance kept");
    // A swap override on the nested instance survives switching back.
    ex(&mut s, "instance.swap", json!({"ids": [inested], "component": star}));
    ex(&mut s, "instance.setProperties", json!({"ids": [i], "properties": {"State": "Default"}}));
    healthy(&s);
    let inested = kids(&s, i)[1];
    assert_eq!(main_of(&s, inested), star);
    assert_eq!(fill(&s, kids(&s, inested)[0]), "FF8800");
}

#[test]
fn nested_overrides_survive_main_restructuring() {
    let mut s = Session::new();
    let (_icon, shape, button, nested) = button(&mut s);
    let other = icon(&mut s, 200.0, "Other", "Shape");
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    let ishape = copy_of(&s, i, copy_of(&s, nested, shape));
    ex(&mut s, "node.set", json!({"id": ishape, "props": {"fill": "#ff00ff"}}));
    // The main wraps its nested instance in a frame, then reorders it.
    let wrap = idv(&ex(&mut s, "object.frameSelection", json!({"ids": [nested]})));
    healthy(&s);
    let ishape = copy_of(&s, i, copy_of(&s, nested, shape));
    assert_eq!(fill(&s, ishape), "FF00FF", "kept when the main moves the nested instance into a frame");
    ex(&mut s, "node.reorder", json!({"id": wrap, "index": 5}));
    healthy(&s);
    assert_eq!(fill(&s, copy_of(&s, i, copy_of(&s, nested, shape))), "FF00FF");
    // The main swaps its nested instance to a main with the same layer.
    ex(&mut s, "instance.swap", json!({"ids": [nested], "component": other}));
    healthy(&s);
    let inested = copy_of(&s, i, nested);
    assert_eq!(main_of(&s, inested), other);
    assert_eq!(fill(&s, kids(&s, inested)[0]), "FF00FF");
}

#[test]
fn detach_keeps_swapped_nested_instances_and_their_overrides() {
    let mut s = Session::new();
    let (_icon, _shape, button, nested) = button(&mut s);
    let other = icon(&mut s, 200.0, "Other", "Glyph");
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    let inested = copy_of(&s, i, nested);
    ex(&mut s, "instance.swap", json!({"ids": [inested], "component": other}));
    let iglyph = kids(&s, inested)[0];
    ex(&mut s, "node.set", json!({"id": iglyph, "props": {"fill": "#00aaff"}}));
    ex(&mut s, "component.detach", json!({"ids": [i]}));
    healthy(&s);
    assert_eq!(main_of(&s, inested), other);
    assert_eq!(node(&s, inested).source, Some(other));
    assert!(!node(&s, inested).overrides.contains("component"));
    let glyph = kids(&s, other)[0];
    assert_eq!(node(&s, iglyph).source, Some(glyph));
    assert_eq!(fill(&s, iglyph), "00AAFF");
    ex(&mut s, "node.set", json!({"id": glyph, "props": {"fill": "#000000", "cornerRadius": 3}}));
    assert_eq!(fill(&s, iglyph), "00AAFF");
    assert_eq!(node(&s, iglyph).corners.radii, [3.0; 4]);
    healthy(&s);
}

#[test]
fn copied_instances_keep_their_overrides() {
    let mut s = Session::new();
    let (icon, shape, button, nested) = button(&mut s);
    ex(&mut s, "component.addProperty", json!({"id": icon, "name": "Filled", "type": "boolean", "default": true, "layer": shape}));
    ex(&mut s, "component.exposeInstance", json!({"id": nested}));
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    let inested = copy_of(&s, i, nested);
    let ishape = kids(&s, inested)[0];
    let ilabel = kids(&s, i)[1];
    ex(&mut s, "node.set", json!({"id": ishape, "props": {"fill": "#ff00ff"}}));
    ex(&mut s, "text.set", json!({"id": ilabel, "characters": "Copied"}));
    ex(&mut s, "instance.setProperties", json!({"ids": [inested], "properties": {"Filled": false}}));
    // The whole instance: overrides and property values come along, and survive main edits.
    ex(&mut s, "edit.copy", json!({"ids": [i]}));
    s.set_selection(vec![]);
    let j = ex(&mut s, "edit.paste", json!({"x": 300, "y": 800}))["ids"][0].as_u64().map(NodeId).unwrap();
    healthy(&s);
    ex(&mut s, "node.set", json!({"id": shape, "props": {"cornerRadius": 4}}));
    ex(&mut s, "node.set", json!({"id": button, "props": {"fill": "#eeeeee"}}));
    healthy(&s);
    let jnested = copy_of(&s, j, nested);
    let jshape = kids(&s, jnested)[0];
    assert_eq!(fill(&s, jshape), "FF00FF");
    assert!(!node(&s, jshape).visible, "property value of the nested instance kept");
    assert_eq!(node(&s, jshape).corners.radii, [4.0; 4]);
    assert_eq!(node(&s, kids(&s, j)[1]).kind.text().unwrap().characters, "Copied");
    assert_eq!(fill(&s, j), "EEEEEE");
    // A nested instance copied out on its own becomes an instance of its own main, same look.
    let inested = copy_of(&s, i, nested);
    ex(&mut s, "edit.copy", json!({"ids": [inested]}));
    s.set_selection(vec![]);
    let k = ex(&mut s, "edit.paste", json!({"x": 900, "y": 800}))["ids"][0].as_u64().map(NodeId).unwrap();
    healthy(&s);
    assert!(!inside_instance(s.doc().unwrap(), k));
    assert_eq!(node(&s, k).source, Some(icon));
    let kshape = kids(&s, k)[0];
    assert_eq!(node(&s, kshape).source, Some(shape));
    assert_eq!(fill(&s, kshape), "FF00FF");
    assert!(node(&s, kshape).overrides.contains("fills"));
    assert!(!node(&s, kshape).visible);
    assert!(!node(&s, kshape).overrides.contains("visible"), "set by its property, not an override");
    ex(&mut s, "instance.setProperties", json!({"ids": [k], "properties": {"Filled": true}}));
    assert!(node(&s, kids(&s, k)[0]).visible);
    ex(&mut s, "node.set", json!({"id": shape, "props": {"cornerRadius": 7}}));
    assert_eq!(node(&s, kids(&s, k)[0]).corners.radii, [7.0; 4]);
    assert_eq!(fill(&s, kids(&s, k)[0]), "FF00FF");
    // A plain layer copied out of an instance is a plain layer.
    let ilabel = kids(&s, i)[1];
    ex(&mut s, "edit.copy", json!({"ids": [ilabel]}));
    s.set_selection(vec![]);
    let t = ex(&mut s, "edit.paste", json!({"x": 900, "y": 1000}))["ids"][0].as_u64().map(NodeId).unwrap();
    assert!(node(&s, t).source.is_none() && node(&s, t).overrides.is_empty());
    healthy(&s);
}

/// `button()` with the main's copy of the icon's Shape filled red, and an instance-swap property
/// `Icon` on the nested icon: (icon, shape, button, nested).
fn button_with_icon_override(s: &mut Session) -> (NodeId, NodeId, NodeId, NodeId) {
    let (icon_main, shape, button, nested) = button(s);
    let main_shape = copy_of(s, nested, shape);
    ex(s, "node.set", json!({"id": main_shape, "props": {"fill": "#ff0000"}}));
    ex(s, "component.addProperty", json!({"id": button, "name": "Icon", "type": "instanceSwap", "default": icon_main, "layer": nested}));
    (icon_main, shape, button, nested)
}

/// Swap instance `i`'s icon to `to` by its instance-swap property `Icon`.
fn swap_icon(s: &mut Session, i: NodeId, to: NodeId) {
    ex(s, "instance.setProperties", json!({"ids": [i], "properties": {"Icon": to}}));
    healthy(s);
}

#[test]
fn a_main_override_carries_onto_a_swapped_nested_instance() {
    // Documented: overrides survive a swap when layer names match, and a swapped icon takes the
    // colour the main component set (forum thread with staff replies). Rows: by the instance-swap
    // property and by instance.swap, onto a matching and an unmatched name. The main's size
    // override is geometry and stays out; the instance's own override wins over the main's.
    let mut s = Session::new();
    let (_icon, shape, button, nested) = button_with_icon_override(&mut s);
    let main_shape = copy_of(&s, nested, shape);
    ex(&mut s, "node.set", json!({"id": main_shape, "props": {"width": 10}}));
    let other = icon(&mut s, 200.0, "Other", "Shape");
    let unmatched = icon(&mut s, 300.0, "Unmatched", "Glyph");
    for (by_property, to, want) in [(true, other, "FF0000"), (false, other, "FF0000"), (true, unmatched, "111111"), (false, unmatched, "111111")] {
        let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
        if by_property {
            swap_icon(&mut s, i, to);
        } else {
            let inested = copy_of(&s, i, nested);
            ex(&mut s, "instance.swap", json!({"ids": [inested], "component": to}));
            healthy(&s);
        }
        let glyph = kids(&s, copy_of(&s, i, nested))[0];
        assert_eq!(fill(&s, glyph), want, "by property {by_property}, to {to}");
        assert_eq!(node(&s, glyph).width, 20.0, "the main's size override stays out");
    }
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 600})));
    let glyph = kids(&s, copy_of(&s, i, nested))[0];
    ex(&mut s, "node.set", json!({"id": glyph, "props": {"fill": "#0000ff"}}));
    swap_icon(&mut s, i, other);
    assert_eq!(fill(&s, kids(&s, copy_of(&s, i, nested))[0]), "0000FF", "the instance's own override wins");
}

#[test]
fn a_main_override_carries_onto_a_swap_one_level_deeper() {
    // As above for a Button instance inside a Toolbar main, swapped in a Toolbar instance.
    let mut s = Session::new();
    let (_icon, _shape, button, nested) = button_with_icon_override(&mut s);
    let other = icon(&mut s, 200.0, "Other", "Shape");
    let bar = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 600, "width": 300, "height": 60, "name": "Toolbar"})));
    let inner = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 10, "y": 10, "parent": bar})));
    let toolbar = idv(&ex(&mut s, "component.create", json!({"ids": [bar]})));
    let t = idv(&ex(&mut s, "instance.create", json!({"component": toolbar, "x": 0, "y": 800})));
    let icon_in_t = copy_of(&s, t, copy_of(&s, inner, nested));
    ex(&mut s, "instance.swap", json!({"ids": [icon_in_t], "component": other}));
    healthy(&s);
    assert_eq!(fill(&s, kids(&s, icon_in_t)[0]), "FF0000");
}

#[test]
fn a_swapped_nested_instance_keeps_the_main_override_it_took() {
    // Documented (staff reply): later edits of the main's icon colour don't reach instances that
    // swapped, and do reach the rest. Undo and redo follow; resetting the override shows the icon
    // main's own fill.
    let mut s = Session::new();
    let (_icon, shape, button, nested) = button_with_icon_override(&mut s);
    let other = icon(&mut s, 200.0, "Other", "Shape");
    let swapped = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    let kept = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 500})));
    swap_icon(&mut s, swapped, other);
    let glyph = |s: &Session, i: NodeId| fill(s, kids(s, copy_of(s, i, nested))[0]);
    let main_shape = copy_of(&s, nested, shape);
    ex(&mut s, "node.set", json!({"id": main_shape, "props": {"fill": "#00ff00"}}));
    healthy(&s);
    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "00FF00".into()));
    s.undo().unwrap();
    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "FF0000".into()));
    s.redo().unwrap();
    assert_eq!((glyph(&s, swapped), glyph(&s, kept)), ("FF0000".into(), "00FF00".into()));
    let swapped_glyph = kids(&s, copy_of(&s, swapped, nested))[0];
    ex(&mut s, "component.resetOverride", json!({"id": swapped_glyph, "group": "fills"}));
    healthy(&s);
    assert_eq!(glyph(&s, swapped), "111111");
}

#[test]
fn a_swapped_in_icon_keeps_its_own_overrides_to_itself() {
    // Docs silent; pinned: what an icon main overrides inside itself stays that main's. After a
    // swap to it, its edits still reach the instance; a second swap doesn't carry them on.
    let mut s = Session::new();
    let (_icon, _shape, button, nested) = button_with_icon_override(&mut s);
    let dot = icon(&mut s, 200.0, "Dot", "Shape");
    let with_dot = |s: &mut Session, x: f64, name: &str, fill: Option<&str>| {
        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 300, "width": 24, "height": 24, "name": name})));
        let d = idv(&ex(s, "instance.create", json!({"component": dot, "x": 0, "y": 0, "parent": f})));
        if let Some(c) = fill {
            let shape = kids(s, d)[0];
            ex(s, "node.set", json!({"id": shape, "props": {"fill": c}}));
        }
        (idv(&ex(s, "component.create", json!({"ids": [f]}))), d)
    };
    let (other2, dot2) = with_dot(&mut s, 300.0, "Other2", Some("#0000ff"));
    let (other3, _) = with_dot(&mut s, 400.0, "Other3", None);
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 300, "y": 400})));
    swap_icon(&mut s, i, other2);
    let shape_in = |s: &Session| kids(s, kids(s, copy_of(s, i, nested))[0])[0];
    assert_eq!(fill(&s, shape_in(&s)), "0000FF");
    let shape2 = kids(&s, dot2)[0];
    ex(&mut s, "node.set", json!({"id": shape2, "props": {"fill": "#00ffff"}}));
    healthy(&s);
    assert_eq!(fill(&s, shape_in(&s)), "00FFFF", "Other2's own edit reaches it");
    swap_icon(&mut s, i, other3);
    assert_eq!(fill(&s, shape_in(&s)), "111111", "Other2's override doesn't carry onto Other3");
}

#[test]
fn a_swapped_out_icons_own_overrides_stay_with_it() {
    // Docs silent; pinned: what the Button's default icon main overrides inside itself isn't the
    // Button main's to carry. Icon A colours its Base's Shape green; swapping to icon B, also built
    // on Base, shows Base's own fill.
    let mut s = Session::new();
    let base = icon(&mut s, 0.0, "Base", "Shape");
    let on_base = |s: &mut Session, x: f64, name: &str| {
        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 500, "width": 24, "height": 24, "name": name})));
        let b = idv(&ex(s, "instance.create", json!({"component": base, "x": 0, "y": 0, "parent": f})));
        (idv(&ex(s, "component.create", json!({"ids": [f]}))), b)
    };
    let (a, a_base) = on_base(&mut s, 100.0, "A");
    let (b, _) = on_base(&mut s, 200.0, "B");
    let a_shape = kids(&s, a_base)[0];
    ex(&mut s, "node.set", json!({"id": a_shape, "props": {"fill": "#00ff00"}}));
    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 700, "width": 40, "height": 40, "name": "Button"})));
    let nested = idv(&ex(&mut s, "instance.create", json!({"component": a, "x": 4, "y": 4, "parent": f})));
    let button = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
    ex(&mut s, "component.addProperty", json!({"id": button, "name": "Icon", "type": "instanceSwap", "default": a, "layer": nested}));
    let i = idv(&ex(&mut s, "instance.create", json!({"component": button, "x": 0, "y": 800})));
    swap_icon(&mut s, i, b);
    let shape = kids(&s, kids(&s, copy_of(&s, i, nested))[0])[0];
    assert_eq!(fill(&s, shape), "111111");
    assert!(node(&s, shape).overrides.is_empty());
}

#[test]
fn a_slot_the_main_filled_shows_the_swapped_in_mains_content() {
    // Docs silent on slot content across a swap; pinned: a Chip the Panel main put in its card's
    // slot doesn't carry onto the swapped-in card, which shows its own default content.
    let mut s = Session::new();
    let card = |s: &mut Session, x: f64, name: &str| {
        let f = idv(&ex(s, "frame.create", json!({"x": x, "y": 0, "width": 100, "height": 60, "name": name})));
        let content = idv(&ex(s, "frame.create", json!({"x": 0, "y": 0, "width": 100, "height": 60, "parent": f, "name": "Content"})));
        ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 40, "height": 20, "parent": content, "props": {"name": format!("{name} default")}}));
        let c = idv(&ex(s, "component.create", json!({"ids": [f]})));
        ex(s, "component.makeSlot", json!({"id": content}));
        c
    };
    let (a, b) = (card(&mut s, 0.0, "A"), card(&mut s, 200.0, "B"));
    let chip = icon(&mut s, 400.0, "Chip", "Dot");
    let f = idv(&ex(&mut s, "frame.create", json!({"x": 0, "y": 400, "width": 200, "height": 100, "name": "Panel"})));
    let nested = idv(&ex(&mut s, "instance.create", json!({"component": a, "x": 0, "y": 0, "parent": f})));
    let panel = idv(&ex(&mut s, "component.create", json!({"ids": [f]})));
    ex(&mut s, "instance.slotInsert", json!({"id": nested, "slot": "Content", "component": chip, "replace": true}));
    ex(&mut s, "component.addProperty", json!({"id": panel, "name": "Card", "type": "instanceSwap", "default": a, "layer": nested}));
    let i = idv(&ex(&mut s, "instance.create", json!({"component": panel, "x": 0, "y": 700})));
    ex(&mut s, "instance.setProperties", json!({"ids": [i], "properties": {"Card": b}}));
    healthy(&s);
    let content = kids(&s, copy_of(&s, i, nested))[0];
    let names: Vec<String> = kids(&s, content).into_iter().map(|k| node(&s, k).name.clone()).collect();
    assert_eq!(names, ["B default"]);
    assert!(!node(&s, content).overrides.contains(SLOT));
}