//! Reviewed policy experiment using the production projection and translator.
//! No production admission or atomic-refusal behavior is tested here.
use super::*;

struct Mixed {
    f: Fixture,
    an: Id,
    xn: Id,
    yn: Id,
    internal: Id,
    include_performer: bool,
}

fn mixed(layer: Layer, collapsed: bool, obstacle: bool, include_performer: bool) -> Mixed {
    let mut f = fixture(layer);
    let work = f.p.elements[&f.w].kind();
    let exchange = match layer {
        Layer::Oa => RelationKind::Interaction,
        Layer::Sa => RelationKind::FunctionalExchange,
    };
    let x = f.p.add_element(work, layer, "X", Some(f.w)).unwrap();
    let y = f.p.add_element(work, layer, "Y", Some(f.w)).unwrap();
    let outside = f.p.add_element(work, layer, "Outside", None).unwrap();
    let xn = f.p.place(f.d, x, xy(140., 200.));
    let yn = f.p.place(f.d, y, xy(940., 200.));
    f.p.place(f.d, outside, xy(1800., 800.));
    f.p.relate(RelationKind::Allocation, "A owns X", f.a, x);
    f.p.relate(RelationKind::Allocation, "B owns Y", f.b, y);
    // FunctionalExchange's actual builder creates valid function input/output
    // ports; do not manufacture Interaction records between SA Functions.
    let internal = f.p.relate(exchange, "X to Y", x, y);
    let external = f.p.relate(exchange, "Y to Outside", y, outside);
    let an = f.p.diagrams[&f.d]
        .nodes
        .values()
        .find(|n| n.element == f.a)
        .unwrap()
        .id;
    let d = f.p.diagrams.get_mut(&f.d).unwrap();
    d.nodes.get_mut(&f.n).unwrap().position = xy(100., 800.);
    d.nodes.get_mut(&an).unwrap().collapsed = collapsed;
    d.routes = vec![route(internal), route(external)];
    if obstacle {
        let id =
            f.p.add_element(work, layer, "Stationary obstacle", None)
                .unwrap();
        f.p.place(f.d, id, xy(550., 230.));
    }
    validate_candidate(&f.p).unwrap();
    let captured = scope(&f);
    assert_eq!(captured.uniform, Uniform::MixedOrUnresolved);
    assert_eq!(
        captured.placements.keys().copied().collect::<BTreeSet<_>>(),
        BTreeSet::from([f.n, xn, yn])
    );
    // Explicit control: the real current API still refuses Arrange for this root.
    assert!(matches!(
        plan_semantics(&f.p, &captured, Destination::LayoutOnly, &BTreeMap::new()),
        Err(Refusal::MixedLayoutRequired)
    ));
    assert!(matches!(
        plan_semantics(
            &f.p,
            &captured,
            Destination::Performer(f.a),
            &BTreeMap::new()
        ),
        Err(Refusal::MixedLayoutRequired)
    ));
    Mixed {
        f,
        an,
        xn,
        yn,
        internal,
        include_performer,
    }
}

fn affected(m: &Mixed) -> BTreeSet<Id> {
    let mut ids: BTreeSet<_> = scope(&m.f).placements.keys().copied().collect();
    let mut expected = BTreeSet::from([m.f.n, m.xn, m.yn]);
    if m.include_performer {
        ids.insert(m.an);
        ids.extend(projection::descendant_nodes(&m.f.p, m.f.d, m.an));
        expected.insert(m.an);
    }
    assert_eq!(ids, expected);
    ids
}

// Diagnostic expansion changes only a temporary Diagram. Include affected
// descendants and ancestors even when the normal projection hides them.
// Unrelated folded interiors are intentionally OUTSIDE this diagnostic domain.
fn diagnostic(p: &Project, diagram: Id, ids: &BTreeSet<Id>) -> ProjectedView {
    let mut d = p.diagrams[&diagram].clone();
    for (id, node) in &mut d.nodes {
        if ids.contains(id)
            || projection::descendant_nodes(p, diagram, *id)
                .iter()
                .any(|n| ids.contains(n))
        {
            node.collapsed = false;
        }
    }
    projection::project_diagram(p, &d)
}

fn rigid(before: &ProjectedView, after: &ProjectedView, ids: &BTreeSet<Id>) {
    for id in ids {
        let old = before.nodes.iter().find(|n| n.id == *id).unwrap();
        let new = after.nodes.iter().find(|n| n.id == *id).unwrap();
        assert_eq!(new.position, xy(old.position.x + 400., old.position.y));
        assert_eq!(new.size, old.size, "no reflow of an affected footprint");
    }
}

// The only experimental bypass: use the pure general geometry command instead
// of plan_semantics(LayoutOnly), whose mixed-root pre-veto is asserted above.
// This is not a fabricated Scope or a call to singleton check_geometry with a
// falsely enlarged Scope. The combined scene uses the real overlap predicate.
fn candidate(m: &Mixed) -> (Command, Project) {
    let ids = affected(m);
    let command =
        oa_core::diagram_edit::translate_placements(&m.f.p, m.f.d, &ids, xy(400., 0.)).unwrap();
    let actual = prepare_command(&m.f.p, &command).unwrap().project;
    validate_candidate(&actual).unwrap();
    // Independent literal expected Project: no planner or route helper oracle.
    let mut expected = m.f.p.clone();
    let d = expected.diagrams.get_mut(&m.f.d).unwrap();
    for (id, position) in [
        (m.f.n, xy(500., 800.)),
        (m.xn, xy(540., 200.)),
        (m.yn, xy(1340., 200.)),
    ] {
        d.nodes.get_mut(&id).unwrap().position = position;
    }
    if m.include_performer {
        d.nodes.get_mut(&m.an).unwrap().position = xy(500., 100.);
    }
    let internal = d.routes.iter_mut().find(|r| r.edge == m.internal).unwrap();
    internal.waypoints = vec![xy(820., 400.), xy(820., 550.)];
    assert_eq!(
        actual, expected,
        "complete records, including folds, routes, other view and relations"
    );
    (command, actual)
}

#[test]
fn mixed_arrange_experiment_distributed_root_and_performer_can_translate_rigidly() {
    for layer in [Layer::Oa, Layer::Sa] {
        let enclosure_height = match layer {
            Layer::Oa => 218.,
            Layer::Sa => 256.,
        };
        for include_performer in [false, true] {
            for collapsed in [false, true] {
                let m = mixed(layer, collapsed, false, include_performer);
                let accepted = m.f.p.clone();
                let (command, actual) = candidate(&m);
                let ids = affected(&m);
                let before = projection::project_view(&accepted, m.f.d);
                let after = projection::project_view(&actual, m.f.d);
                let before_expanded = diagnostic(&accepted, m.f.d, &ids);
                let after_expanded = diagnostic(&actual, m.f.d, &ids);
                assert!(
                    !overlaps(&before, &after),
                    "visible scene must admit the combined move"
                );
                assert!(
                    !overlaps(&before_expanded, &after_expanded),
                    "expanded scene must admit the combined move"
                );
                rigid(&before_expanded, &after_expanded, &ids);
                for node in after.nodes.iter().chain(&after_expanded.nodes) {
                    assert!(
                        (Rect {
                            position: node.position,
                            size: node.size
                        })
                        .valid()
                    );
                }
                // Explicit selected headers remain visible. Native clipping/readability
                // and complete group gesture admission are intentionally not claimed.
                assert!(after.nodes.iter().any(|n| n.id == m.f.n));
                if include_performer {
                    assert!(after.nodes.iter().any(|n| n.id == m.an));
                } else {
                    assert_eq!(
                        actual.diagrams[&m.f.d].nodes[&m.an],
                        accepted.diagrams[&m.f.d].nodes[&m.an]
                    );
                    assert_eq!(node(&before_expanded, m.an).position, xy(100., 100.));
                    assert_eq!(
                        node(&before_expanded, m.an).size,
                        Size {
                            width: 288.,
                            height: enclosure_height
                        }
                    );
                    assert_eq!(node(&after_expanded, m.an).position, xy(100., 100.));
                    assert_eq!(
                        node(&after_expanded, m.an).size,
                        Size {
                            width: 688.,
                            height: enclosure_height
                        }
                    );
                }
                assert_eq!(roundtrip(&accepted, command), actual);
                assert_eq!(m.f.p, accepted);
            }
        }
    }
}

#[test]
fn mixed_arrange_experiment_detects_moved_folded_child_collision() {
    for layer in [Layer::Oa, Layer::Sa] {
        let expected_overlap = match layer {
            Layer::Oa => 13696.,
            Layer::Sa => 20116.,
        };
        let m = mixed(layer, true, true, true);
        let accepted = m.f.p.clone();
        let (_, actual) = candidate(&m);
        let ids = affected(&m);
        let before = projection::project_view(&accepted, m.f.d);
        let after = projection::project_view(&actual, m.f.d);
        assert!(!before.nodes.iter().any(|n| n.id == m.xn));
        assert!(!after.nodes.iter().any(|n| n.id == m.xn));
        assert!(
            !overlaps(&before, &after),
            "must distinguish hidden collision from ordinary visible refusal"
        );
        let before_expanded = diagnostic(&accepted, m.f.d, &ids);
        let after_expanded = diagnostic(&actual, m.f.d, &ids);
        rigid(&before_expanded, &after_expanded, &ids);
        let obstacle = before_expanded
            .nodes
            .iter()
            .find(|n| n.position == xy(550., 230.))
            .unwrap()
            .id;
        assert_eq!(
            overlap(
                node(&before_expanded, m.xn),
                node(&before_expanded, obstacle)
            ),
            0.
        );
        assert_eq!(
            overlap(node(&after_expanded, m.xn), node(&after_expanded, obstacle)),
            expected_overlap
        );
        assert!(
            overlaps(&before_expanded, &after_expanded),
            "combined diagnostic scene must refuse"
        );
        // Detection only: there is no production group admission/commit API here.
        assert_eq!(m.f.p, accepted);
    }
}

fn node(view: &ProjectedView, id: Id) -> &ProjectedNode {
    view.nodes.iter().find(|n| n.id == id).unwrap()
}

#[test]
fn mixed_arrange_experiment_detects_stationary_enclosure_growth_collision() {
    for layer in [Layer::Oa, Layer::Sa] {
        let enclosure_height = match layer {
            Layer::Oa => 218.,
            Layer::Sa => 256.,
        };
        let mut m = mixed(layer, false, false, true);
        let kind = m.f.p.elements[&m.f.w].kind();
        let z =
            m.f.p
                .add_element(kind, layer, "Stationary Z", None)
                .unwrap();
        let zn = m.f.p.place(m.f.d, z, xy(1200., 100.));
        validate_candidate(&m.f.p).unwrap();
        let accepted = m.f.p.clone();
        let (_, actual) = candidate(&m);
        let bn = accepted.diagrams[&m.f.d]
            .nodes
            .values()
            .find(|n| n.element == m.f.b)
            .unwrap()
            .id;
        let before = projection::project_view(&accepted, m.f.d);
        let after = projection::project_view(&actual, m.f.d);
        assert_eq!(node(&before, bn).position, xy(900., 100.));
        assert_eq!(
            node(&before, bn).size,
            Size {
                width: 288.,
                height: enclosure_height
            }
        );
        assert_eq!(node(&after, bn).position, xy(900., 100.));
        assert_eq!(
            node(&after, bn).size,
            Size {
                width: 688.,
                height: enclosure_height
            }
        );
        assert_eq!(node(&after, zn).position, xy(1200., 100.));
        assert_eq!(
            node(&after, zn).size,
            Size {
                width: 224.,
                height: 94.
            }
        );
        assert_eq!(overlap(node(&before, bn), node(&before, zn)), 0.);
        assert_eq!(overlap(node(&after, bn), node(&after, zn)), 21056.);
        assert_eq!(node(&after, m.yn).position, xy(1340., 200.));
        assert_eq!(
            node(&after, m.yn).position.y
                - (node(&after, zn).position.y + node(&after, zn).size.height),
            6.
        );
        for id in affected(&m) {
            assert_eq!(overlap(node(&before, id), node(&before, zn)), 0.);
            assert_eq!(overlap(node(&after, id), node(&after, zn)), 0.);
        }
        assert_eq!(
            actual.diagrams[&m.f.d].nodes[&bn],
            accepted.diagrams[&m.f.d].nodes[&bn]
        );
        assert_eq!(
            actual.diagrams[&m.f.d].nodes[&zn],
            accepted.diagrams[&m.f.d].nodes[&zn]
        );
        assert!(
            overlaps(&before, &after),
            "complete scene must detect stationary enclosure growth"
        );
        let ids = affected(&m);
        assert!(overlaps(
            &diagnostic(&accepted, m.f.d, &ids),
            &diagnostic(&actual, m.f.d, &ids)
        ));
        assert_eq!(m.f.p, accepted);
    }
}

#[test]
fn mixed_arrange_experiment_unrelated_folded_interiors_are_outside_diagnostic_domain() {
    for layer in [Layer::Oa, Layer::Sa] {
        // Independent source-derived literals: SA's auto-created function ports
        // raise projected X/Y height to 76 + 28 * (1 + 1), while Z is port-free.
        let (work_height, expected_overlap) = match layer {
            Layer::Oa => (94., 13696.),
            Layer::Sa => (132., 20116.),
        };
        let mut m = mixed(layer, true, false, true);
        let performer = match layer {
            Layer::Oa => Kind::Actor,
            Layer::Sa => Kind::SystemActor,
        };
        let kind = m.f.p.elements[&m.f.w].kind();
        let d =
            m.f.p
                .add_element(performer, layer, "Unrelated D", None)
                .unwrap();
        let z =
            m.f.p
                .add_element(kind, layer, "Unrelated hidden Z", None)
                .unwrap();
        m.f.p.relate(RelationKind::Allocation, "D owns Z", d, z);
        let dn = m.f.p.place(m.f.d, d, xy(2500., 100.));
        let zn = m.f.p.place(m.f.d, z, xy(550., 230.));
        m.f.p
            .diagrams
            .get_mut(&m.f.d)
            .unwrap()
            .nodes
            .get_mut(&dn)
            .unwrap()
            .collapsed = true;
        validate_candidate(&m.f.p).unwrap();
        let accepted = m.f.p.clone();
        let (_, actual) = candidate(&m);
        let ids = affected(&m);
        let before = diagnostic(&accepted, m.f.d, &ids);
        let after = diagnostic(&actual, m.f.d, &ids);
        assert!(!before.nodes.iter().any(|n| n.id == zn));
        assert!(!after.nodes.iter().any(|n| n.id == zn));
        assert!(
            !overlaps(&before, &after),
            "chosen diagnostic domain excludes unrelated folded contents"
        );
        assert!(!overlaps(
            &projection::project_view(&accepted, m.f.d),
            &projection::project_view(&actual, m.f.d)
        ));
        let all_unfolded = |p: &Project| {
            let mut diagram = p.diagrams[&m.f.d].clone();
            for n in diagram.nodes.values_mut() {
                n.collapsed = false;
            }
            projection::project_diagram(p, &diagram)
        };
        let broad_before = all_unfolded(&accepted);
        let broad_after = all_unfolded(&actual);
        assert_eq!(node(&broad_before, m.xn).position, xy(140., 200.));
        assert_eq!(node(&broad_after, m.xn).position, xy(540., 200.));
        assert_eq!(
            node(&broad_after, m.xn).size,
            Size {
                width: 224.,
                height: work_height
            }
        );
        assert_eq!(node(&broad_before, zn).position, xy(550., 230.));
        assert_eq!(node(&broad_after, zn).position, xy(550., 230.));
        assert_eq!(
            node(&broad_after, zn).size,
            Size {
                width: 224.,
                height: 94.
            }
        );
        assert_eq!(
            overlap(node(&broad_before, m.xn), node(&broad_before, zn)),
            0.
        );
        assert_eq!(
            overlap(node(&broad_after, m.xn), node(&broad_after, zn)),
            expected_overlap
        );
        // Other newly exposed enclosure pairs may also overlap. X/Z is a
        // concrete discriminator, not a claim that it is the only cause.
        assert!(overlaps(&broad_before, &broad_after));
        for id in [dn, zn] {
            assert_eq!(
                actual.diagrams[&m.f.d].nodes[&id],
                accepted.diagrams[&m.f.d].nodes[&id]
            );
        }
        assert!(actual.diagrams[&m.f.d].nodes[&dn].collapsed);
        assert_eq!(m.f.p, accepted);
    }
}