use super::{
TextProblem, capitalise, counted,
pairing::{check_edited, pair_tiers},
parse_text, same, same_all, sentence, tier_label,
};
use crate::session::{EditChange, EditorSession, SessionEditError};
use indicatrix::{geometry::meet_solver::MeetConstraint, optics::materials::GemMaterial};
use indicatrix_cut_core::{
ConstraintTier, Design, Edit, ScheduleMeta, ScheduleState, TierId, built_in_refractive_index,
};
use indicatrix_formats::asc::{AscSchedule, AscTier, MeetInstruction};
use std::{
borrow::Cow,
collections::{BTreeMap, BTreeSet},
};
const MAX_LISTED_WARNINGS: usize = 5;
#[derive(Debug, Default, Clone, Copy)]
struct TierDiff {
angle: bool,
angle_ignored: bool,
name: bool,
indices: bool,
depth: bool,
notes: bool,
meet_replaced: bool,
detached_dropped: usize,
}
struct MergedTier {
tier: ConstraintTier,
id: TierId,
old: Option<usize>,
depth_changed: bool,
}
fn imported_meet_of(tier: &AscTier) -> Option<MeetConstraint> {
match tier.meet_instruction() {
Some(MeetInstruction::Meet(names)) => Some(MeetConstraint::MeetNamed(names)),
Some(MeetInstruction::ScaleReference | MeetInstruction::LevelGirdle) => None,
_ => Some(MeetConstraint::MeetExisting),
}
}
fn new_tier(edited: &AscTier) -> ConstraintTier {
ConstraintTier {
angle_deg: edited.angle_deg,
name: edited.name.clone(),
indices: edited.indices.clone(),
constraint: MeetConstraint::ScaleReference(edited.mast),
imported_meet: imported_meet_of(edited),
original_notes: Some(edited.notes.clone()),
detached: Vec::new(),
}
}
fn merge_one(
old: &ConstraintTier,
base: &AscTier,
edited: &AscTier,
driven: bool,
) -> (ConstraintTier, TierDiff) {
let mut tier = old.clone();
let mut diff = TierDiff::default();
if !same(base.angle_deg, edited.angle_deg) {
if driven {
diff.angle_ignored = true;
} else {
tier.angle_deg = edited.angle_deg;
diff.angle = true;
}
}
if base.name != edited.name {
tier.name.clone_from(&edited.name);
diff.name = true;
}
if !same_all(&base.indices, &edited.indices) {
tier.indices.clone_from(&edited.indices);
let before = tier.detached.len();
tier.detached
.retain(|mark| edited.indices.iter().any(|index| same(*index, *mark)));
diff.detached_dropped = before - tier.detached.len();
diff.indices = true;
}
diff.depth = !same(base.mast, edited.mast);
diff.notes = base.notes != edited.notes;
if diff.depth || diff.notes {
diff.meet_replaced = !matches!(old.constraint, MeetConstraint::ScaleReference(_));
tier.constraint = MeetConstraint::ScaleReference(edited.mast);
tier.imported_meet = imported_meet_of(edited);
tier.original_notes = Some(edited.notes.clone());
}
(tier, diff)
}
#[derive(Default)]
struct Findings {
meta_changed: Vec<String>,
meta_lost: Vec<String>,
added: Vec<String>,
removed: Vec<String>,
renamed: Vec<String>,
angles: Vec<String>,
indices: Vec<String>,
depths: Vec<String>,
notes: Vec<String>,
reordered: bool,
meet_replaced: Vec<String>,
ignored_angles: Vec<String>,
dropped_targets: Vec<String>,
dropped_relations: Vec<String>,
detached_dropped: Vec<String>,
broken_meets: Vec<String>,
removed_notes: usize,
removed_offsets: usize,
removed_targets: usize,
removed_relations: usize,
parse_notes: Vec<String>,
}
impl Findings {
fn record(
&mut self,
old: &ConstraintTier,
new: &ConstraintTier,
position: usize,
diff: TierDiff,
) {
let label = tier_label(new, position);
if diff.name {
self.renamed
.push(format!("{} to {label}", tier_label(old, position)));
}
if diff.angle {
self.angles.push(label.clone());
}
if diff.angle_ignored {
self.ignored_angles.push(label.clone());
}
if diff.indices {
self.indices.push(label.clone());
}
if diff.depth {
self.depths.push(label.clone());
}
if diff.notes {
self.notes.push(label.clone());
}
if diff.meet_replaced {
self.meet_replaced.push(label.clone());
}
if diff.detached_dropped > 0 {
self.detached_dropped.push(label);
}
}
fn note_removed(&mut self, design: &Design, pairs: &[Option<usize>]) {
let kept: BTreeSet<usize> = pairs.iter().flatten().copied().collect();
for (index, tier) in design.tiers.iter().enumerate() {
if kept.contains(&index) {
continue;
}
self.removed.push(tier_label(tier, index));
let id = design.tier_ids[index];
self.removed_notes += usize::from(design.tier_notes.contains_key(&index));
self.removed_offsets += usize::from(design.cheater_offsets_deg.contains_key(&index));
self.removed_targets += usize::from(design.tier_targets.contains_key(&id));
self.removed_relations += usize::from(design.tier_relations.contains_key(&id));
}
}
fn removed_with(&self) -> Option<String> {
let parts: Vec<String> = [
(self.removed_notes, "note"),
(self.removed_offsets, "cheater offset"),
(self.removed_targets, "target"),
(self.removed_relations, "relation"),
]
.into_iter()
.filter(|(count, _)| *count > 0)
.map(|(count, noun)| counted(count, noun))
.collect();
(!parts.is_empty()).then(|| format!("Removed along with them: {}.", parts.join(", ")))
}
fn parse_note_lines(&self) -> Vec<String> {
let mut lines: Vec<String> = self
.parse_notes
.iter()
.take(MAX_LISTED_WARNINGS)
.map(|note| capitalise(note))
.collect();
let rest = self.parse_notes.len().saturating_sub(MAX_LISTED_WARNINGS);
if rest > 0 {
lines.push(format!("{rest} more lines were ignored."));
}
lines
}
fn into_report(mut self) -> ApplyReport {
let mut changed = std::mem::take(&mut self.meta_changed);
changed.extend(sentence("Added tiers:", &self.added));
changed.extend(sentence("Renamed:", &self.renamed));
changed.extend(sentence("Angle changes on:", &self.angles));
changed.extend(sentence("Index list changes on:", &self.indices));
changed.extend(sentence("Cut depth changes on:", &self.depths));
changed.extend(sentence("Instruction text changes on:", &self.notes));
if self.reordered {
changed.push("The order of the tiers changes.".to_owned());
}
let mut lost = Vec::new();
lost.extend(sentence("Removed tiers:", &self.removed));
lost.extend(self.removed_with());
lost.extend(sentence(
"These tiers followed a meet rule and now keep the fixed depth written in the text:",
&self.meet_replaced,
));
lost.extend(sentence(
"These tiers have a depth target that the depth in the text replaces:",
&self.dropped_targets,
));
lost.extend(sentence(
"These tiers follow a relation, so the angle in the text is ignored:",
&self.ignored_angles,
));
lost.extend(sentence(
"These tiers lose their relation because a tier it reads is removed:",
&self.dropped_relations,
));
lost.extend(sentence(
"These tiers lose their detached index marks because the indices changed:",
&self.detached_dropped,
));
lost.extend(sentence(
"These meet rules now name a tier that is gone:",
&self.broken_meets,
));
lost.extend(std::mem::take(&mut self.meta_lost));
lost.extend(self.parse_note_lines());
ApplyReport { changed, lost }
}
}
fn material_decides_index(design: &Design, custom: &[GemMaterial]) -> bool {
design.material.refractive_index_override.is_some()
|| design.material.name.as_deref().is_some_and(|name| {
custom.iter().any(|gem| gem.name.eq_ignore_ascii_case(name))
|| built_in_refractive_index(name).is_some()
})
}
fn user_footnotes(schedule: &AscSchedule, generated: &[String]) -> Vec<String> {
schedule
.footnotes
.iter()
.filter(|footnote| !generated.contains(footnote))
.cloned()
.collect()
}
fn merge_meta(
design: &Design,
base: &AscSchedule,
edited: &AscSchedule,
custom: &[GemMaterial],
findings: &mut Findings,
) -> ScheduleMeta {
let mut meta = design.meta.clone();
if edited.gemcad_version != base.gemcad_version {
meta.gemcad_version.clone_from(&edited.gemcad_version);
findings
.meta_changed
.push("The GemCad version line changes.".to_owned());
}
if edited.gear_teeth != base.gear_teeth {
meta.gear_teeth = edited.gear_teeth;
findings.meta_changed.push(format!(
"The gear changes from {} to {} teeth.",
base.gear_teeth, edited.gear_teeth
));
findings.meta_lost.push(
"The index numbers are used as written. They are not rescaled to the new gear."
.to_owned(),
);
}
if !same(edited.gear_reference_angle, base.gear_reference_angle) {
meta.gear_reference_angle = edited.gear_reference_angle;
findings.meta_changed.push(format!(
"The gear reference angle changes from {} to {}.",
base.gear_reference_angle, edited.gear_reference_angle
));
}
if edited.symmetry_order != base.symmetry_order {
meta.symmetry_order = edited.symmetry_order;
findings.meta_changed.push(format!(
"The symmetry order changes from {} to {}.",
base.symmetry_order, edited.symmetry_order
));
}
if edited.mirror != base.mirror {
meta.mirror = edited.mirror;
let now = if edited.mirror { "on" } else { "off" };
findings
.meta_changed
.push(format!("Mirror symmetry is now {now}."));
}
if !same(edited.refractive_index, base.refractive_index) {
meta.refractive_index = edited.refractive_index;
findings.meta_changed.push(format!(
"The refractive index changes from {} to {}.",
base.refractive_index, edited.refractive_index
));
if material_decides_index(design, custom) {
findings.meta_lost.push(
"The material sets the refractive index, so the I line only changes the stored \
fallback value."
.to_owned(),
);
}
}
if edited.headers != base.headers {
meta.headers.clone_from(&edited.headers);
findings
.meta_changed
.push("The header lines change.".to_owned());
}
let mut generated = AscSchedule::default();
design.append_concave_footnotes(&mut generated);
let before = user_footnotes(base, &generated.footnotes);
let after = user_footnotes(edited, &generated.footnotes);
if before != after {
meta.footnotes = after;
findings
.meta_changed
.push("The footnote lines change.".to_owned());
}
meta
}
fn merge_tiers(
design: &Design,
base: &AscSchedule,
edited: &AscSchedule,
pairs: &[Option<usize>],
findings: &mut Findings,
) -> Vec<MergedTier> {
let mut next_id = design.next_tier_id;
let mut merged: Vec<MergedTier> = Vec::with_capacity(edited.tiers.len());
for (edited_tier, pair) in edited.tiers.iter().zip(pairs) {
let position = merged.len();
if let Some(old_index) = *pair {
let old = &design.tiers[old_index];
let driven = design.is_tier_driven(old_index);
let (tier, diff) = merge_one(old, &base.tiers[old_index], edited_tier, driven);
findings.record(old, &tier, position, diff);
merged.push(MergedTier {
tier,
id: design.tier_ids[old_index],
old: Some(old_index),
depth_changed: diff.depth,
});
} else {
let tier = new_tier(edited_tier);
findings.added.push(tier_label(&tier, position));
merged.push(MergedTier {
tier,
id: TierId(next_id),
old: None,
depth_changed: false,
});
next_id += 1;
}
}
findings.note_removed(design, pairs);
findings.reordered = !pairs.iter().flatten().is_sorted();
merged
}
fn name_set<'a>(tiers: impl Iterator<Item = &'a ConstraintTier>) -> BTreeSet<String> {
tiers
.flat_map(ConstraintTier::names)
.map(str::to_ascii_lowercase)
.collect()
}
fn broken_meets(design: &Design, merged: &[MergedTier]) -> Vec<String> {
let before = name_set(design.tiers.iter());
let after = name_set(merged.iter().map(|entry| &entry.tier));
let mut broken = Vec::new();
for (position, entry) in merged.iter().enumerate() {
let MeetConstraint::MeetNamed(wanted) = &entry.tier.constraint else {
continue;
};
for name in wanted {
let key = name.to_ascii_lowercase();
if before.contains(&key) && !after.contains(&key) {
broken.push(format!(
"{} (needs {name})",
tier_label(&entry.tier, position)
));
}
}
}
broken
}
fn assemble(
design: &Design,
meta: ScheduleMeta,
merged: &[MergedTier],
findings: &mut Findings,
) -> ScheduleState {
let new_ids: BTreeSet<TierId> = merged.iter().map(|entry| entry.id).collect();
let added = merged.iter().filter(|entry| entry.old.is_none()).count();
let mut state = ScheduleState {
meta,
tiers: merged.iter().map(|entry| entry.tier.clone()).collect(),
tier_ids: merged.iter().map(|entry| entry.id).collect(),
next_tier_id: design.next_tier_id + added as u64,
cheater_offsets_deg: BTreeMap::new(),
tier_notes: BTreeMap::new(),
tier_targets: BTreeMap::new(),
tier_relations: BTreeMap::new(),
};
let label_of = |id: TierId| {
merged
.iter()
.enumerate()
.find(|(_, entry)| entry.id == id)
.map_or_else(String::new, |(position, entry)| {
tier_label(&entry.tier, position)
})
};
for (position, entry) in merged.iter().enumerate() {
let Some(old) = entry.old else {
continue;
};
if let Some(offset) = design.cheater_offsets_deg.get(&old) {
state.cheater_offsets_deg.insert(position, *offset);
}
if let Some(note) = design.tier_notes.get(&old) {
state.tier_notes.insert(position, note.clone());
}
}
let depth_set: BTreeSet<TierId> = merged
.iter()
.filter(|entry| entry.depth_changed)
.map(|entry| entry.id)
.collect();
for (id, target) in &design.tier_targets {
if !new_ids.contains(id) {
continue;
}
if depth_set.contains(id) {
findings.dropped_targets.push(label_of(*id));
} else {
state.tier_targets.insert(*id, *target);
}
}
for (id, relation) in &design.tier_relations {
if !new_ids.contains(id) {
continue;
}
if relation
.references()
.iter()
.all(|read| new_ids.contains(read))
{
state.tier_relations.insert(*id, relation.clone());
} else {
findings.dropped_relations.push(label_of(*id));
}
}
state
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ApplyReport {
pub changed: Vec<String>,
pub lost: Vec<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ApplyPlan {
pub state: ScheduleState,
pub report: ApplyReport,
noop: bool,
}
impl ApplyPlan {
#[must_use]
pub const fn is_noop(&self) -> bool {
self.noop
}
}
fn synced(design: &Design) -> Cow<'_, Design> {
if design.tier_ids.len() == design.tiers.len() {
Cow::Borrowed(design)
} else {
let mut copy = design.clone();
copy.ensure_tier_ids();
Cow::Owned(copy)
}
}
fn stale_problem() -> TextProblem {
TextProblem::general(
"This text no longer matches the open design. Use Revert to write it again.",
)
}
pub fn plan_apply(
design: &Design,
base_text: &str,
edited_text: &str,
custom: &[GemMaterial],
) -> Result<ApplyPlan, TextProblem> {
let design = synced(design);
let design: &Design = &design;
let base = parse_text(base_text).map_err(|_| stale_problem())?;
if base.schedule.tiers.len() != design.tiers.len() {
return Err(stale_problem());
}
let edited = parse_text(edited_text)?;
let pairs = pair_tiers(&base.schedule.tiers, &edited.schedule.tiers);
check_edited(design, &base, &edited, &pairs)?;
let mut findings = Findings::default();
let meta = merge_meta(
design,
&base.schedule,
&edited.schedule,
custom,
&mut findings,
);
let merged = merge_tiers(
design,
&base.schedule,
&edited.schedule,
&pairs,
&mut findings,
);
let state = assemble(design, meta, &merged, &mut findings);
findings.broken_meets = broken_meets(design, &merged);
findings.parse_notes.clone_from(&edited.schedule.warnings);
let noop = state == ScheduleState::of(design);
Ok(ApplyPlan {
state,
report: findings.into_report(),
noop,
})
}
pub fn apply_plan(
session: &mut EditorSession,
plan: ApplyPlan,
) -> Result<Option<EditChange>, SessionEditError> {
if plan.noop {
return Ok(None);
}
session
.try_apply(Edit::ReplaceSchedule(Box::new(plan.state)))
.map(Some)
}