use std::collections::{HashMap, HashSet};
use crate::forme::MemberId;
use crate::forme::member::Lifecycle;
use crate::forme::tree::GraphTree;
#[derive(Clone, Debug)]
pub struct ExternalTreeSnapshot<N: MemberId> {
pub members: HashSet<N>,
pub children: HashMap<N, Vec<N>>,
pub active: Option<N>,
pub visible: HashSet<N>,
pub expanded: HashSet<N>,
pub visible_order: Vec<N>,
}
#[derive(Clone, Debug)]
pub enum ParityDivergence<N: MemberId> {
MissingFromExternal(N),
MissingFromForme(N),
TopologyMismatch {
member: N,
forme_parent: Option<N>,
external_parent: Option<N>,
},
ActiveMismatch {
forme: Option<N>,
external: Option<N>,
},
VisibilityMismatch {
member: N,
in_forme: bool,
in_external: bool,
},
ExpansionMismatch {
member: N,
in_forme: bool,
in_external: bool,
},
VisibleOrderMismatch {
forme_order: Vec<N>,
external_order: Vec<N>,
},
}
#[derive(Clone, Debug)]
pub struct ParityReport<N: MemberId> {
pub divergences: Vec<ParityDivergence<N>>,
pub forme_only: usize,
pub external_only: usize,
pub topology_mismatches: usize,
pub visibility_mismatches: usize,
pub expansion_mismatches: usize,
pub active_matches: bool,
pub visible_order_matches: bool,
}
impl<N: MemberId> ParityReport<N> {
pub fn is_clean(&self) -> bool {
self.divergences.is_empty()
}
pub fn membership_matches(&self) -> bool {
self.forme_only == 0 && self.external_only == 0
}
pub fn structural_match(&self) -> bool {
self.membership_matches() && self.topology_mismatches == 0
}
pub fn full_match(&self) -> bool {
self.structural_match()
&& self.active_matches
&& self.visibility_mismatches == 0
&& self.expansion_mismatches == 0
&& self.visible_order_matches
}
}
pub fn compare<N: MemberId>(
tree: &GraphTree<N>,
external: &ExternalTreeSnapshot<N>,
) -> ParityReport<N> {
let mut divergences = Vec::new();
let mut forme_only = 0usize;
let mut external_only = 0usize;
let mut topology_mismatches = 0usize;
let mut visibility_mismatches = 0usize;
let mut expansion_mismatches = 0usize;
let gt_members: HashSet<N> = tree.members().map(|(id, _)| id.clone()).collect();
for id in >_members {
if !external.members.contains(id) {
let entry = tree.get(id);
let is_cold = entry.is_some_and(|e| e.lifecycle == Lifecycle::Cold);
if !is_cold {
divergences.push(ParityDivergence::MissingFromExternal(id.clone()));
forme_only += 1;
}
}
}
for id in &external.members {
if !gt_members.contains(id) {
divergences.push(ParityDivergence::MissingFromForme(id.clone()));
external_only += 1;
}
}
let shared: HashSet<&N> = gt_members.intersection(&external.members).collect();
if !external.children.is_empty() {
for id in &shared {
let gt_parent = tree.topology().parent_of(id).cloned();
let ext_parent = external
.children
.iter()
.find(|(_, children)| children.contains(id))
.map(|(parent, _)| parent.clone());
if gt_parent != ext_parent {
divergences.push(ParityDivergence::TopologyMismatch {
member: (*id).clone(),
forme_parent: gt_parent,
external_parent: ext_parent,
});
topology_mismatches += 1;
}
}
}
let active_matches = external.active.is_none() || tree.active().cloned() == external.active;
if !active_matches {
divergences.push(ParityDivergence::ActiveMismatch {
forme: tree.active().cloned(),
external: external.active.clone(),
});
}
let gt_visible: HashSet<N> = tree
.members()
.filter(|(_, e)| e.is_visible_in_pane())
.map(|(id, _)| id.clone())
.collect();
for id in gt_visible.difference(&external.visible) {
divergences.push(ParityDivergence::VisibilityMismatch {
member: id.clone(),
in_forme: true,
in_external: false,
});
visibility_mismatches += 1;
}
for id in external.visible.difference(>_visible) {
if gt_members.contains(id) {
divergences.push(ParityDivergence::VisibilityMismatch {
member: id.clone(),
in_forme: false,
in_external: true,
});
visibility_mismatches += 1;
}
}
if !external.expanded.is_empty() {
let gt_expanded: HashSet<N> = tree.expanded_members().cloned().collect();
for id in gt_expanded.difference(&external.expanded) {
if external.members.contains(id) {
divergences.push(ParityDivergence::ExpansionMismatch {
member: id.clone(),
in_forme: true,
in_external: false,
});
expansion_mismatches += 1;
}
}
for id in external.expanded.difference(>_expanded) {
if gt_members.contains(id) {
divergences.push(ParityDivergence::ExpansionMismatch {
member: id.clone(),
in_forme: false,
in_external: true,
});
expansion_mismatches += 1;
}
}
}
let visible_order_matches = if external.visible_order.is_empty() {
true } else {
let gt_order: Vec<N> = tree
.visible_rows()
.into_iter()
.map(|row| row.member.clone())
.collect();
let matches = gt_order == external.visible_order;
if !matches {
divergences.push(ParityDivergence::VisibleOrderMismatch {
forme_order: gt_order,
external_order: external.visible_order.clone(),
});
}
matches
};
ParityReport {
divergences,
forme_only,
external_only,
topology_mismatches,
visibility_mismatches,
expansion_mismatches,
active_matches,
visible_order_matches,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::forme::layout::LayoutMode;
use crate::forme::lens::ProjectionLens;
use crate::forme::member::Provenance;
use crate::forme::nav::NavAction;
fn build_tree() -> GraphTree<u64> {
let mut tree = GraphTree::new(LayoutMode::TreeStyleTabs, ProjectionLens::Traversal);
tree.apply(NavAction::Attach {
member: 1,
provenance: Provenance::Anchor,
});
tree.apply(NavAction::Attach {
member: 2,
provenance: Provenance::Traversal {
source: 1,
edge_kind: None,
},
});
tree.apply(NavAction::Attach {
member: 3,
provenance: Provenance::Traversal {
source: 1,
edge_kind: None,
},
});
tree.apply(NavAction::SetLifecycle(1, Lifecycle::Active));
tree.apply(NavAction::SetLifecycle(2, Lifecycle::Warm));
tree.apply(NavAction::Activate(1));
tree
}
fn matching_snapshot() -> ExternalTreeSnapshot<u64> {
let mut children = HashMap::new();
children.insert(1, vec![2, 3]);
ExternalTreeSnapshot {
members: HashSet::from([1, 2, 3]),
children,
active: Some(1),
visible: HashSet::from([1, 2]),
expanded: HashSet::new(), visible_order: Vec::new(), }
}
#[test]
fn clean_parity_report() {
let tree = build_tree();
let snapshot = matching_snapshot();
let report = compare(&tree, &snapshot);
assert!(report.is_clean());
assert!(report.membership_matches());
assert!(report.structural_match());
assert!(report.active_matches);
assert!(report.visible_order_matches);
assert_eq!(report.expansion_mismatches, 0);
}
#[test]
fn missing_member_in_external() {
let tree = build_tree();
let mut snapshot = matching_snapshot();
snapshot.members.remove(&2);
snapshot.visible.remove(&2);
let report = compare(&tree, &snapshot);
assert!(!report.membership_matches());
assert_eq!(report.forme_only, 1);
}
#[test]
fn cold_members_not_flagged_as_divergence() {
let tree = build_tree();
let mut snapshot = matching_snapshot();
snapshot.members.remove(&3);
let report = compare(&tree, &snapshot);
assert_eq!(report.forme_only, 0);
}
#[test]
fn topology_mismatch_detected() {
let tree = build_tree();
let mut snapshot = matching_snapshot();
snapshot.children.get_mut(&1).unwrap().retain(|&x| x != 2);
let report = compare(&tree, &snapshot);
assert!(!report.structural_match());
assert_eq!(report.topology_mismatches, 1);
}
#[test]
fn active_mismatch_detected() {
let tree = build_tree();
let mut snapshot = matching_snapshot();
snapshot.active = Some(2);
let report = compare(&tree, &snapshot);
assert!(!report.active_matches);
}
#[test]
fn visibility_mismatch_detected() {
let tree = build_tree();
let mut snapshot = matching_snapshot();
snapshot.visible.remove(&2);
let report = compare(&tree, &snapshot);
assert_eq!(report.visibility_mismatches, 1);
}
#[test]
fn active_none_in_external_not_flagged() {
let tree = build_tree(); let mut snapshot = matching_snapshot();
snapshot.active = None;
let report = compare(&tree, &snapshot);
assert!(
report.active_matches,
"None external active should not flag mismatch"
);
}
#[test]
fn expansion_mismatch_detected() {
let mut tree = build_tree();
tree.apply(NavAction::ToggleExpand(1));
let mut snapshot = matching_snapshot();
snapshot.expanded = HashSet::from([99u64]);
let report = compare(&tree, &snapshot);
assert!(report.expansion_mismatches > 0);
}
#[test]
fn expansion_check_skipped_when_external_expanded_empty() {
let mut tree = build_tree();
tree.apply(NavAction::ToggleExpand(1));
let snapshot = matching_snapshot(); let report = compare(&tree, &snapshot);
assert_eq!(report.expansion_mismatches, 0);
}
#[test]
fn visible_order_mismatch_detected() {
let tree = build_tree(); let mut snapshot = matching_snapshot();
snapshot.visible_order = vec![2, 1];
let report = compare(&tree, &snapshot);
assert!(!report.visible_order_matches);
}
#[test]
fn visible_order_check_skipped_when_external_order_empty() {
let tree = build_tree();
let snapshot = matching_snapshot(); let report = compare(&tree, &snapshot);
assert!(report.visible_order_matches);
}
}