use super::{IndexChip, TierRow};
use indicatrix::geometry::meet_solver::{
Block, MeetConstraint, MeetNameResolver, TokenResolution, classify_blocks,
};
use indicatrix_cut_core::{Design, OrbitUnit, TierTarget};
pub(super) fn constraint_kind_and_text(
constraint: &MeetConstraint,
target: Option<TierTarget>,
) -> (i32, String) {
if let Some(target) = target {
return match target {
TierTarget::DepthMm(mm) => (3, mm.to_string()),
TierTarget::GirdleThicknessMm(mm) => (4, mm.to_string()),
TierTarget::TableWidthMm(mm) => (5, mm.to_string()),
};
}
match constraint {
MeetConstraint::MeetExisting => (0, String::new()),
MeetConstraint::MeetNamed(names) => (1, names.join(", ")),
MeetConstraint::ScaleReference(value) => (2, value.to_string()),
}
}
#[must_use]
pub fn format_angle_cell(angle_deg: f64) -> String {
format!("{angle_deg:.2}")
}
#[must_use]
pub fn format_index_value(value: f64) -> String {
if value.fract().abs() < 1e-9 {
format!("{value:.0}")
} else {
format!("{value:.2}")
}
}
#[must_use]
pub fn index_chip_items(indices: &[f64], detached: &[f64]) -> Vec<IndexChip> {
indices
.iter()
.map(|&position| IndexChip {
position: position as f32,
label: format_index_value(position),
detached: detached.iter().any(|&d| (d - position).abs() < 1e-9),
})
.collect()
}
pub(super) fn imported_meet_text(imported_meet: Option<&MeetConstraint>) -> String {
match imported_meet {
Some(MeetConstraint::MeetExisting) => "meets an unspecified vertex".to_string(),
Some(MeetConstraint::MeetNamed(names)) => format!("meets {}", names.join(", ")),
None | Some(MeetConstraint::ScaleReference(_)) => String::new(),
}
}
pub(super) fn orbit_status_text(units: &[OrbitUnit]) -> (String, bool) {
if units.iter().all(|u| u.members.len() <= 1) {
return (String::new(), false);
}
match units {
[one] => {
if one.is_complete() {
(format!("orbit x{}", one.members.len()), false)
} else {
(
format!("{}/{} orbit", one.members.len(), one.expected_len),
true,
)
}
}
many => {
let incomplete = many.iter().filter(|u| !u.is_complete()).count();
if incomplete == 0 {
(format!("{} orbits", many.len()), false)
} else if incomplete == many.len() {
("not symmetric".to_string(), true)
} else {
(
format!("{} orbits ({incomplete} incomplete)", many.len()),
true,
)
}
}
}
}
#[must_use]
pub fn tiers_incomplete_under_proposed_symmetry(
design: &Design,
symmetry_order: u32,
mirror: bool,
) -> usize {
let mut proposed_meta = design.meta.clone();
proposed_meta.symmetry_order = symmetry_order;
proposed_meta.mirror = mirror;
design
.tiers
.iter()
.filter(|tier| {
let units = indicatrix_cut_core::orbit_units(&tier.indices, &proposed_meta);
orbit_status_text(&units).1
})
.count()
}
#[must_use]
pub fn tier_label(design: &Design, tier_index: usize) -> String {
let Some(tier) = design.tiers.get(tier_index) else {
return format!("tier {}", tier_index + 1);
};
if tier.name.is_empty() || indicatrix_cut_core::is_legacy_123_abc(&tier.name) {
let labels = indicatrix_cut_core::compute_tier_labels(&design.tiers);
labels.get(tier_index).map_or_else(
|| format!("tier {}", tier_index + 1),
|l| format!("tier {} ({})", tier_index + 1, l.code),
)
} else {
format!("tier {} ({})", tier_index + 1, tier.name)
}
}
pub fn apply_multi_selection(
rows: &mut [TierRow],
multi_selected: &std::collections::BTreeSet<usize>,
) {
for row in rows {
row.multi_selected =
usize::try_from(row.index).is_ok_and(|index| multi_selected.contains(&index));
}
}
#[must_use]
pub fn first_unresolved_meet_name(design: &Design, names: &[String]) -> Option<String> {
let inputs = design.meet_tier_inputs();
let resolver = MeetNameResolver::new(&inputs);
names
.iter()
.find(|name| matches!(resolver.resolve_token(name), TokenResolution::Unresolved))
.cloned()
}
#[must_use]
pub fn representative_crown_and_pavilion_angles_deg(design: &Design) -> (Option<f64>, Option<f64>) {
let blocks = classify_blocks(&design.meet_tier_inputs());
let mut crown_main: Option<f64> = None;
let mut crown_largest: Option<f64> = None;
let mut pavilion_main: Option<f64> = None;
let mut pavilion_largest: Option<f64> = None;
for (tier, block) in design.tiers.iter().zip(&blocks) {
let is_main = tier.name.to_lowercase().contains("main");
match block {
Block::Crown => {
let angle = tier.angle_deg;
crown_largest = Some(crown_largest.map_or(angle, |m| angle.max(m)));
if is_main {
crown_main = Some(crown_main.map_or(angle, |m| angle.max(m)));
}
}
Block::Pavilion => {
let magnitude = tier.angle_deg.abs();
pavilion_largest = Some(pavilion_largest.map_or(magnitude, |m| magnitude.max(m)));
if is_main {
pavilion_main = Some(pavilion_main.map_or(magnitude, |m| magnitude.max(m)));
}
}
Block::Girdle => {}
}
}
(
crown_main.or(crown_largest),
pavilion_main.or(pavilion_largest),
)
}
pub(super) fn tier_margin_and_risk(
tier_angle_deg: f64,
block: Block,
n_d: f64,
pavilion_partner_deg: Option<f64>,
) -> (String, i32) {
let risk_level_of = |risk: indicatrix_cut_core::Risk| match risk {
indicatrix_cut_core::Risk::Safe => 0,
indicatrix_cut_core::Risk::Marginal => 1,
indicatrix_cut_core::Risk::Windows => 2,
};
match block {
Block::Pavilion => {
let margin = indicatrix_cut_core::tier_margin_deg(tier_angle_deg, n_d);
let risk_level =
risk_level_of(indicatrix_cut_core::windowing_risk(tier_angle_deg, n_d));
(format!("{margin:+.1}\u{b0}"), risk_level)
}
Block::Crown => {
let Some(pavilion_deg) = pavilion_partner_deg else {
return (String::new(), -1);
};
let margin =
indicatrix_cut_core::crown_window_margin_deg(pavilion_deg, tier_angle_deg, n_d);
let risk_level = risk_level_of(indicatrix_cut_core::crown_windowing_risk(
pavilion_deg,
tier_angle_deg,
n_d,
));
(format!("{margin:+.1}\u{b0} (est.)"), risk_level)
}
Block::Girdle => (String::new(), -1),
}
}