use super::{EditChange, EditorSession, relations::linked_rung_relation};
use crate::{
loading::{
naming::{series_names, unique_mirror_name},
parse_angle_only_with_names, parse_index_list, parse_step_series_form,
unique_duplicate_name,
},
manipulate::{dependents::clear_dependant_edits, tiers_meeting},
};
use indicatrix_cut_core::{ConstraintTier, Edit, EditError};
use std::{collections::BTreeSet, fmt};
mod concave;
#[cfg(test)]
mod tests;
const UNNAMED: &str = "(unnamed)";
fn display_name(name: &str) -> String {
if name.is_empty() {
UNNAMED.to_string()
} else {
name.to_string()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DuplicateOutcome {
pub change: EditChange,
pub new_index: usize,
pub source_label: String,
pub duplicate_label: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RemovedTier {
pub change: EditChange,
pub name: String,
pub facet_count: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MovedTier {
pub change: EditChange,
pub target: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RemoveTierError {
HasDependants {
subject: String,
dependants: Vec<usize>,
labels: Vec<String>,
},
Edit(EditError),
}
impl fmt::Display for RemoveTierError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::HasDependants {
subject, labels, ..
} => write!(
f,
"Cannot remove {subject}: still named as a meet target by {}. Change those \
tiers first, or confirm the removal to clear the references.",
labels.join(", ")
),
Self::Edit(error) => fmt::Display::fmt(error, f),
}
}
}
impl std::error::Error for RemoveTierError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::HasDependants { .. } => None,
Self::Edit(error) => Some(error),
}
}
}
impl From<EditError> for RemoveTierError {
fn from(error: EditError) -> Self {
Self::Edit(error)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DetachOutcome {
pub change: EditChange,
pub detached: bool,
pub label: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MirrorOutcome {
pub change: EditChange,
pub new_index: usize,
pub label: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GeneratedSeries {
pub change: EditChange,
pub start_index: usize,
pub added: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InlineAngle {
Missing,
NoChange,
Applied(EditChange),
}
fn add_tier_edits(tiers: Vec<ConstraintTier>, start_index: usize) -> Vec<Edit> {
tiers
.into_iter()
.enumerate()
.map(|(offset, tier)| Edit::AddTier {
index: start_index + offset,
tier,
})
.collect()
}
#[must_use]
pub const fn selection_after_remove(selected: Option<usize>, removed: usize) -> Option<usize> {
match selected {
Some(index) if index == removed => None,
Some(index) if index > removed => Some(index - 1),
other => other,
}
}
impl EditorSession {
pub fn duplicate_tier(&mut self, index: usize) -> Result<Option<DuplicateOutcome>, EditError> {
let Some(source) = self.design.tiers.get(index) else {
return Ok(None);
};
let mut duplicate = source.clone();
let source_label = display_name(&source.name);
let existing_names: Vec<String> =
self.design.tiers.iter().map(|t| t.name.clone()).collect();
duplicate.name = unique_duplicate_name(&source.name, &existing_names);
let duplicate_label = duplicate.name.clone();
duplicate.imported_meet = None;
let new_index = index + 1;
let change = self.apply(Edit::AddTier {
index: new_index,
tier: duplicate,
})?;
Ok(Some(DuplicateOutcome {
change,
new_index,
source_label,
duplicate_label,
}))
}
pub fn remove_tier(&mut self, index: usize) -> Result<RemovedTier, RemoveTierError> {
self.remove_tier_with(index, false)
}
pub fn remove_tier_with(
&mut self,
index: usize,
cascade: bool,
) -> Result<RemovedTier, RemoveTierError> {
let (name, facet_count) = self.design.tiers.get(index).map_or_else(
|| (UNNAMED.to_string(), 0),
|tier| (display_name(&tier.name), tier.indices.len()),
);
let dependants = tiers_meeting(&self.design, index);
if !dependants.is_empty() && !cascade {
return Err(self.has_dependants(name, dependants));
}
let edit = if dependants.is_empty() {
Edit::RemoveTier { index }
} else {
let mut steps = clear_dependant_edits(&self.design, index);
steps.push(Edit::RemoveTier { index });
Edit::Batch(steps)
};
let change = self.apply(edit)?;
Ok(RemovedTier {
change,
name,
facet_count,
})
}
fn has_dependants(&self, subject: String, dependants: Vec<usize>) -> RemoveTierError {
let labels = dependants
.iter()
.filter_map(|&index| {
self.design
.tiers
.get(index)
.map(|tier| super::tier_nudge_label(tier, index))
})
.collect();
RemoveTierError::HasDependants {
subject,
dependants,
labels,
}
}
pub fn move_tier(
&mut self,
index: usize,
direction: i32,
) -> Result<Option<MovedTier>, EditError> {
let tier_count = self.design.tiers.len();
let target = if direction < 0 {
index.checked_sub(1)
} else {
index.checked_add(1).filter(|&t| t < tier_count)
};
let Some(target) = target else {
return Ok(None);
};
let change = self.apply(Edit::MoveTier {
from: index,
to: target,
})?;
Ok(Some(MovedTier { change, target }))
}
pub fn toggle_detach(&mut self, index: usize) -> Result<Option<DetachOutcome>, EditError> {
let Some(tier) = self.design.tiers.get(index) else {
return Ok(None);
};
let edit = if tier.detached.is_empty() {
self.design.detach_all_in_tier(index)
} else {
self.design.reattach_all_in_tier(index)
};
let change = edit.and_then(|edit| self.apply(edit))?;
let tier = self.design.tiers.get(index);
Ok(Some(DetachOutcome {
change,
detached: tier.is_some_and(|tier| !tier.detached.is_empty()),
label: tier.map_or_else(String::new, |tier| super::tier_nudge_label(tier, index)),
}))
}
pub fn remove_multi_selected(&mut self) -> Result<usize, RemoveTierError> {
self.remove_multi_selected_with(false)
}
pub fn remove_multi_selected_with(&mut self, cascade: bool) -> Result<usize, RemoveTierError> {
let targets: Vec<usize> = self.multi_selected.iter().rev().copied().collect();
let removed = targets.len();
let outside: BTreeSet<usize> = targets
.iter()
.flat_map(|&index| tiers_meeting(&self.design, index))
.filter(|dependant| !self.multi_selected.contains(dependant))
.collect();
if !outside.is_empty() && !cascade {
let dependants = outside.into_iter().collect();
return Err(self.has_dependants("the selected tiers".to_string(), dependants));
}
let mut last_err = None;
self.begin_relation_notice_command();
for index in targets {
let outcome = if cascade {
self.remove_tier_with(index, true).map(|_| ())
} else {
self.apply(Edit::RemoveTier { index })
.map(|_| ())
.map_err(RemoveTierError::from)
};
if let Err(e) = outcome {
last_err = Some(e);
}
}
self.end_relation_notice_command();
last_err.map_or(Ok(removed), Err)
}
pub fn adopt_all_imported_meets(&mut self) -> Result<usize, EditError> {
self.adopt_imported_meets(None)
}
pub fn adopt_selected_imported_meets(&mut self) -> Result<usize, EditError> {
let selected = self.multi_selected.clone();
self.adopt_imported_meets(Some(&selected))
}
pub fn adopt_imported_meet(&mut self, index: usize) -> Result<bool, EditError> {
let Some(constraint) = self
.design
.tiers
.get(index)
.and_then(|tier| tier.imported_meet.clone())
else {
return Ok(false);
};
self.apply(Edit::SetConstraint { index, constraint })?;
Ok(true)
}
fn adopt_imported_meets(&mut self, only: Option<&BTreeSet<usize>>) -> Result<usize, EditError> {
let edits: Vec<Edit> = self
.design
.tiers
.iter()
.enumerate()
.filter(|(index, _)| only.is_none_or(|set| set.contains(index)))
.filter_map(|(index, tier)| {
tier.imported_meet
.clone()
.map(|constraint| Edit::SetConstraint { index, constraint })
})
.collect();
if edits.is_empty() {
return Ok(0);
}
let count = edits.len();
self.apply(Edit::Batch(edits))?;
Ok(count)
}
pub fn mirror_tier_to_other_block(
&mut self,
index: usize,
name_suffix: &str,
) -> Result<Option<MirrorOutcome>, EditError> {
let Some(source) = self.design.tiers.get(index) else {
return Ok(None);
};
let mut mirrored = source.mirrored_to_other_block(name_suffix);
let existing_names: Vec<String> =
self.design.tiers.iter().map(|t| t.name.clone()).collect();
mirrored.name = unique_mirror_name(
&source.name,
name_suffix,
mirrored.angle_deg,
&existing_names,
);
let label = mirrored.name.clone();
let new_index = self.design.tiers.len();
let change = self.apply(Edit::AddTier {
index: new_index,
tier: mirrored,
})?;
Ok(Some(MirrorOutcome {
change,
new_index,
label,
}))
}
pub fn generate_step_series(
&mut self,
name_prefix: &str,
start_angle_text: &str,
angle_step_text: &str,
count: i32,
indices_text: &str,
anchor_text: &str,
) -> Result<GeneratedSeries, String> {
let (tiers, _, _) = self.step_series_tiers(
name_prefix,
start_angle_text,
angle_step_text,
count,
indices_text,
anchor_text,
)?;
let start_index = self.design.tiers.len();
let edits = add_tier_edits(tiers, start_index);
let added = edits.len();
let change = self.apply(Edit::Batch(edits)).map_err(|e| e.to_string())?;
Ok(GeneratedSeries {
change,
start_index,
added,
})
}
pub fn generate_step_series_linked(
&mut self,
name_prefix: &str,
start_angle_text: &str,
angle_step_text: &str,
count: i32,
indices_text: &str,
anchor_text: &str,
) -> Result<GeneratedSeries, String> {
let (tiers, start_angle, angle_step) = self.step_series_tiers(
name_prefix,
start_angle_text,
angle_step_text,
count,
indices_text,
anchor_text,
)?;
let start_index = self.design.tiers.len();
let first_id = self.design.peek_next_tier_id();
let side = if start_angle.is_sign_negative() {
-1.0
} else {
1.0
};
let mut edits = add_tier_edits(tiers, start_index);
let added = edits.len();
edits.extend((1..added).map(|rung| Edit::SetTierRelation {
index: start_index + rung,
relation: Some(linked_rung_relation(first_id, rung, angle_step, side)),
}));
let change = self
.try_apply(Edit::Batch(edits))
.map_err(|e| e.to_string())?;
Ok(GeneratedSeries {
change,
start_index,
added,
})
}
fn step_series_tiers(
&self,
name_prefix: &str,
start_angle_text: &str,
angle_step_text: &str,
count: i32,
indices_text: &str,
anchor_text: &str,
) -> Result<(Vec<ConstraintTier>, f64, f64), String> {
let (start_angle, angle_step, count, first_constraint) =
parse_step_series_form(start_angle_text, angle_step_text, count, anchor_text)?;
let indices = parse_index_list(indices_text, self.design.meta.gear_teeth_abs())?;
let mut tiers = ConstraintTier::step_series(
name_prefix,
start_angle,
angle_step,
count,
&indices,
&first_constraint,
);
let existing_names: Vec<String> =
self.design.tiers.iter().map(|t| t.name.clone()).collect();
let angles: Vec<f64> = tiers.iter().map(|tier| tier.angle_deg).collect();
for (tier, name) in
tiers
.iter_mut()
.zip(series_names(name_prefix, &angles, &existing_names))
{
tier.name = name;
}
Ok((tiers, start_angle, angle_step))
}
pub fn set_tier_angle_from_text(
&mut self,
index: usize,
text: &str,
) -> Result<InlineAngle, String> {
let Some(current) = self.design.tiers.get(index) else {
return Ok(InlineAngle::Missing);
};
if text.trim_start().starts_with('=') {
let applied = self
.set_tier_relation(index, text)
.map_err(|error| error.to_string())?;
let Some(change) = applied else {
self.history.end_coalesce_run();
return Ok(InlineAngle::NoChange);
};
return Ok(InlineAngle::Applied(change));
}
let design = &self.design;
let magnitude_of = |name: &str| {
let position = design.tier_position_by_name(name).ok()?;
Some(design.tiers.get(position)?.angle_deg.abs())
};
let parsed = parse_angle_only_with_names(text, Some(&magnitude_of))?;
let angle_deg = if parsed == 0.0 {
let typed = text.trim_start();
if typed.starts_with('-')
|| (current.angle_deg.is_sign_negative() && !typed.starts_with('+'))
{
-0.0
} else {
0.0
}
} else if current.angle_deg.is_sign_negative() {
-parsed.abs()
} else {
parsed
};
if angle_deg.to_bits() == current.angle_deg.to_bits() {
self.history.end_coalesce_run();
return Ok(InlineAngle::NoChange);
}
let mut tier = current.clone();
tier.angle_deg = angle_deg;
self.try_apply(Edit::ModifyTier { index, tier })
.map(InlineAngle::Applied)
.map_err(|e| e.to_string())
}
}