use std::collections::{BTreeMap, BTreeSet};
use crate::registry_core::diagnostic::RegistryResult;
use crate::registry_core::identity::NodeId;
use crate::registry_core::plugin::graft::{GraftCut, GraftPlan};
use crate::registry_core::release::{CutTarget, StaticGraftCut};
use super::super::Registry;
use super::super::overlay::{GraftCutRef, Resolution};
use super::RecordedGraft;
use super::reports::RecordReport;
pub struct RecordedOverlay {
pub effective: Registry,
pub reports: Vec<RecordReport>,
}
struct WinningRecord {
path: String,
graft: String,
full: bool,
}
#[derive(Clone, Copy)]
enum PlannedCut {
Declared(usize),
Owned(usize),
}
impl Registry {
pub fn overlay_recorded(
&self,
records: &[RecordedGraft],
declared: &[StaticGraftCut],
external: &Registry,
) -> RegistryResult<RecordedOverlay> {
let mut reports = Vec::new();
let mut declared_slots = BTreeSet::new();
let mut declared_targets = Vec::with_capacity(declared.len());
for cut in declared {
let targets = self.resolve_cut_targets(GraftCutRef::static_cut(cut))?;
declared_slots.extend(targets.iter().copied());
declared_targets.push(targets);
}
let mut winners: BTreeMap<NodeId, Vec<WinningRecord>> = BTreeMap::new();
for record in records {
let resolved = self.resolve_record(record)?;
reports.extend(resolved.reports().iter().cloned());
let Some((slot, path, full)) = resolved.into_slot() else {
continue;
};
if !declared_slots.contains(&slot) {
reports.push(RecordReport::UnkeptSlot {
selector: record.selector.clone(),
target_path: record.document.target_path.clone(),
});
continue;
}
let declaration = declared
.iter()
.zip(&declared_targets)
.find(|(_, targets)| targets.contains(&slot))
.map(|(cut, _)| *cut)
.expect("a declared slot belongs to a declaration");
let declared_graft = declaration.graft().describe();
let recorded_graft = record.document.graft.clone();
if !matches!(external.resolve_node(&recorded_graft), Resolution::One(_)) {
reports.push(RecordReport::RecordSelectorUnresolved {
selector: record.selector.clone(),
graft: recorded_graft,
});
continue;
}
match declaration.graft() {
CutTarget::Id(_) => {
reports.push(RecordReport::TypedDeclarationKept {
slot,
declared: declared_graft,
recorded: recorded_graft,
});
}
CutTarget::Path(_) => {
reports.push(RecordReport::DeclarationOverridden {
slot,
declared: declared_graft,
recorded: recorded_graft.clone(),
});
if declaration.full() != full {
reports.push(RecordReport::GranularityOverridden {
slot,
declared_full: declaration.full(),
recorded_full: full,
});
}
winners.entry(slot).or_default().push(WinningRecord {
path,
graft: recorded_graft,
full,
});
}
}
}
let mut owned_cuts: Vec<GraftCut> = Vec::new();
let mut planned: Vec<PlannedCut> = Vec::new();
for (index, (cut, targets)) in declared.iter().zip(&declared_targets).enumerate() {
let touched = targets.iter().any(|slot| winners.contains_key(slot));
if !touched {
planned.push(PlannedCut::Declared(index));
continue;
}
let declared_graft = cut.graft().describe();
for slot in targets {
if let Some(won) = winners.get(slot) {
for item in won {
owned_cuts.push(GraftCut {
cut: item.path.clone(),
graft: item.graft.clone(),
end: None,
subtree: item.full,
});
planned.push(PlannedCut::Owned(owned_cuts.len() - 1));
}
} else {
let path = self
.path_for(*slot)
.expect("a resolved cut target has a logical path");
owned_cuts.push(GraftCut {
cut: path,
graft: declared_graft.clone(),
end: None,
subtree: cut.full(),
});
planned.push(PlannedCut::Owned(owned_cuts.len() - 1));
}
}
}
let plan = {
let mut plan = GraftPlan::new(self.framework());
plan.cuts = owned_cuts;
plan
};
let cuts = planned.iter().map(|item| match *item {
PlannedCut::Declared(index) => GraftCutRef::static_cut(&declared[index]),
PlannedCut::Owned(index) => GraftCutRef::dynamic(&plan.cuts[index]),
});
let effective = self.overlay_cuts(self.framework(), cuts, external)?;
Ok(RecordedOverlay { effective, reports })
}
}