use super::row_format::{
constraint_kind_and_text, format_angle_cell, format_index_value, imported_meet_text,
orbit_status_text, representative_crown_and_pavilion_angles_deg, tier_label,
tier_margin_and_risk,
};
fn full_precision(value: f64) -> String {
format!("{value}")
}
use super::{TierRow, TierRowKind};
use indicatrix::geometry::meet_solver::{Block, SolveStrategy, SolvedTier, classify_blocks};
use indicatrix_cut_core::{
ConstraintTier, Design, DesignSolveError, ManufacturabilityWarning, MissingAnchor,
design::ConcaveTier,
};
use std::collections::BTreeMap;
mod warnings;
use warnings::TierWarnings;
pub use warnings::{
manufacturability_warnings_tagged, manufacturability_warnings_tagged_with,
solved_manufacturability_warnings,
};
struct TierSolveInfo {
mast: String,
mast_mm: String,
mast_full: String,
strategy: String,
strategy_is_uncertain: bool,
strategy_detail: String,
needs_anchor: bool,
}
struct RowContext<'a> {
tier_blocks: &'a [Block],
warnings: &'a BTreeMap<usize, String>,
pavilion_partner_deg: Option<f64>,
tier_labels: &'a [indicatrix_cut_core::TierLabelInfo],
}
fn build_tier_row(
design: &Design,
index: usize,
tier: &ConstraintTier,
n_d: f64,
info: TierSolveInfo,
row_context: &RowContext<'_>,
) -> TierRow {
let tier_blocks = row_context.tier_blocks;
let warnings = row_context.warnings;
let pavilion_partner_deg = row_context.pavilion_partner_deg;
let (constraint_kind, constraint_text) =
constraint_kind_and_text(&tier.constraint, design.tier_target(index));
let units = indicatrix_cut_core::orbit_units(&tier.indices, &design.meta);
let (orbit_status, orbit_incomplete) = orbit_status_text(&units);
let (margin_text, risk_level) = tier_margin_and_risk(
tier.angle_deg,
tier_blocks[index],
n_d,
pavilion_partner_deg,
);
let code = row_context
.tier_labels
.get(index)
.map(|label| label.code.clone());
let name = if tier.name.trim().is_empty() || indicatrix_cut_core::is_legacy_123_abc(&tier.name)
{
code.clone().unwrap_or_else(|| tier.name.clone())
} else {
tier.name.clone()
};
TierRow {
index: index as i32,
angle_deg: format_angle_cell(tier.angle_deg.abs()),
angle_full: full_precision(tier.angle_deg.abs()),
name,
code: code.unwrap_or_default(),
indices: tier
.indices
.iter()
.copied()
.map(format_index_value)
.collect::<Vec<_>>()
.join(", "),
indices_full: tier
.indices
.iter()
.copied()
.map(full_precision)
.collect::<Vec<_>>()
.join(", "),
constraint_kind,
constraint_text,
mast: info.mast,
mast_mm: info.mast_mm,
mast_full: info.mast_full,
strategy: info.strategy,
strategy_is_uncertain: info.strategy_is_uncertain,
strategy_detail: info.strategy_detail,
needs_anchor: info.needs_anchor,
imported_meet_text: imported_meet_text(tier.imported_meet.as_ref()),
orbit_status,
orbit_incomplete,
is_detached: !tier.detached.is_empty(),
block: block_label(tier_blocks[index]).to_string(),
margin_text,
risk_level,
meet_partners_text: meet_partners_text(design, index),
warning_text: warnings.get(&index).cloned().unwrap_or_default(),
multi_selected: false,
proposed_angle: String::new(),
kind: TierRowKind::Flat,
tool_line: String::new(),
relation_text: design.relation_text(index).unwrap_or_default(),
}
}
#[must_use]
pub fn concave_tool_line(tier: &ConcaveTier) -> String {
tier.second_line_fields().join(" ")
}
fn concave_tier_rows(design: &Design, warnings: &BTreeMap<usize, String>) -> Vec<TierRow> {
let codes = design.tier_codes().concave;
design
.concave_tiers
.iter()
.enumerate()
.map(|(index, tier)| {
let units = indicatrix_cut_core::orbit_units(&tier.indices, &design.meta);
let (orbit_status, orbit_incomplete) = orbit_status_text(&units);
TierRow {
index: index as i32,
angle_deg: format_angle_cell(tier.angle_deg.abs()),
angle_full: full_precision(tier.angle_deg.abs()),
name: tier.name.clone(),
code: codes
.get(index)
.map(|label| label.code.clone())
.unwrap_or_default(),
indices: tier
.indices
.iter()
.copied()
.map(format_index_value)
.collect::<Vec<_>>()
.join(", "),
indices_full: tier
.indices
.iter()
.copied()
.map(full_precision)
.collect::<Vec<_>>()
.join(", "),
mast: "-".to_string(),
strategy: "Tool cut".to_string(),
strategy_detail: tier.instructions.clone(),
orbit_status,
orbit_incomplete,
block: if tier.is_crown_side() {
"Crown"
} else {
"Pavilion"
}
.to_string(),
risk_level: -1,
warning_text: warnings.get(&index).cloned().unwrap_or_default(),
kind: TierRowKind::Concave,
tool_line: concave_tool_line(tier),
..TierRow::default()
}
})
.collect()
}
#[must_use]
pub fn tier_items_stale(design: &Design, n_d: f64) -> Vec<TierRow> {
let tier_blocks = classify_blocks(&design.meet_tier_inputs());
let warnings = TierWarnings::of(design, None);
let (_, pavilion_partner_deg) = representative_crown_and_pavilion_angles_deg(design);
let tier_labels = indicatrix_cut_core::compute_tier_labels(&design.tiers);
let row_context = RowContext {
tier_blocks: &tier_blocks,
warnings: &warnings.flat,
pavilion_partner_deg,
tier_labels: &tier_labels,
};
let mut rows: Vec<TierRow> = design
.tiers
.iter()
.enumerate()
.map(|(index, tier)| {
let info = TierSolveInfo {
mast: "-".to_string(),
mast_mm: String::new(),
mast_full: String::new(),
strategy: "not solved".to_string(),
strategy_is_uncertain: true,
strategy_detail: String::new(),
needs_anchor: false,
};
build_tier_row(design, index, tier, n_d, info, &row_context)
})
.collect();
rows.extend(concave_tier_rows(design, &warnings.concave));
rows
}
#[must_use]
pub fn tier_items_stale_with_last_solved(
design: &Design,
n_d: f64,
last_solved: Option<&[SolvedTier]>,
dirty: &std::collections::BTreeSet<usize>,
) -> Vec<TierRow> {
let last_solved = last_solved.filter(|solved| solved.len() == design.tiers.len());
let Some(last_solved) = last_solved else {
return tier_items_stale(design, n_d);
};
let tier_blocks = classify_blocks(&design.meet_tier_inputs());
let warnings = TierWarnings::of(design, None);
let mm_per_unit = design.yield_report(last_solved).mm_per_unit;
let (_, pavilion_partner_deg) = representative_crown_and_pavilion_angles_deg(design);
let tier_labels = indicatrix_cut_core::compute_tier_labels(&design.tiers);
let row_context = RowContext {
tier_blocks: &tier_blocks,
warnings: &warnings.flat,
pavilion_partner_deg,
tier_labels: &tier_labels,
};
let mut rows: Vec<TierRow> = design
.tiers
.iter()
.enumerate()
.map(|(index, tier)| {
let info = if dirty.contains(&index) {
TierSolveInfo {
mast: "-".to_string(),
mast_mm: String::new(),
mast_full: String::new(),
strategy: "not solved".to_string(),
strategy_is_uncertain: true,
strategy_detail: String::new(),
needs_anchor: false,
}
} else {
let (label, _) = strategy_label(last_solved[index].strategy);
TierSolveInfo {
mast: format!("{:.4}", last_solved[index].mast),
mast_mm: mm_per_unit.map_or_else(String::new, |mm| {
format!("{:.3} mm", last_solved[index].mast * mm)
}),
mast_full: format!("{}", last_solved[index].mast),
strategy: format!("stale ({label})"),
strategy_is_uncertain: true,
strategy_detail: last_solved[index].detail.clone(),
needs_anchor: false,
}
};
build_tier_row(design, index, tier, n_d, info, &row_context)
})
.collect();
rows.extend(concave_tier_rows(design, &warnings.concave));
rows
}
pub fn apply_proposed_angles(tiers: &mut [TierRow], changes: &[indicatrix_cut_core::AngleChange]) {
for change in changes {
if let Some(row) = tiers.get_mut(change.index) {
row.proposed_angle = format_angle_cell(change.to_deg.abs());
}
}
}
fn missing_anchor_tier_blocks(missing: &MissingAnchor, design: &Design) -> BTreeMap<usize, Block> {
missing
.block_details(design)
.into_iter()
.flat_map(|(block, indices)| indices.into_iter().map(move |index| (index, block)))
.collect()
}
fn meet_partners_text(design: &Design, index: usize) -> String {
let Ok(targets) = design.facet_meets(index) else {
return String::new();
};
if targets.is_empty() {
return String::new();
}
format!(
"meets {}",
targets
.into_iter()
.map(|target| tier_label(design, target))
.collect::<Vec<_>>()
.join(", ")
)
}
const fn strategy_label(strategy: SolveStrategy) -> (&'static str, bool) {
match strategy {
SolveStrategy::ScaleReference => ("Scale reference", false),
SolveStrategy::DependencyOrder => ("Dependency order", false),
SolveStrategy::JointGroup => ("Joint group", false),
SolveStrategy::LeastSquaresFallback => ("Least-squares est.", true),
SolveStrategy::Failed => ("FAILED (untrusted)", true),
}
}
#[must_use]
pub fn tier_items(design: &Design, n_d: f64) -> Vec<TierRow> {
let solved = design.solve();
match &solved {
Ok(rows) => tier_items_from_solved(design, rows, n_d),
Err(err) => {
let missing_tier_blocks = match err {
DesignSolveError::MissingAnchor(missing) => {
missing_anchor_tier_blocks(missing, design)
}
DesignSolveError::Mismatch(_)
| DesignSolveError::Solve(_)
| DesignSolveError::Target(_) => BTreeMap::new(),
};
let blocked_detail = if matches!(err, DesignSolveError::MissingAnchor(_)) {
"Another block in this design has no anchor -- see the validation banner above."
.to_string()
} else {
err.to_string()
};
let tier_blocks = classify_blocks(&design.meet_tier_inputs());
let warnings = TierWarnings::of(design, None);
let (_, pavilion_partner_deg) = representative_crown_and_pavilion_angles_deg(design);
let tier_labels = indicatrix_cut_core::compute_tier_labels(&design.tiers);
let row_context = RowContext {
tier_blocks: &tier_blocks,
warnings: &warnings.flat,
pavilion_partner_deg,
tier_labels: &tier_labels,
};
let mut rows: Vec<TierRow> = design
.tiers
.iter()
.enumerate()
.map(|(index, tier)| {
let info = missing_tier_blocks.get(&index).map_or_else(
|| TierSolveInfo {
mast: "-".to_string(),
mast_mm: String::new(),
mast_full: String::new(),
strategy: "blocked".to_string(),
strategy_is_uncertain: true,
strategy_detail: blocked_detail.clone(),
needs_anchor: false,
},
|&block| TierSolveInfo {
mast: "?".to_string(),
mast_mm: String::new(),
mast_full: String::new(),
strategy: "no anchor yet".to_string(),
strategy_is_uncertain: true,
strategy_detail: MissingAnchor::block_sentence(block),
needs_anchor: true,
},
);
build_tier_row(design, index, tier, n_d, info, &row_context)
})
.collect();
rows.extend(concave_tier_rows(design, &warnings.concave));
rows
}
}
}
#[must_use]
pub fn tier_items_from_solved(design: &Design, solved: &[SolvedTier], n_d: f64) -> Vec<TierRow> {
tier_items_from_solved_and(design, solved, n_d, &TierWarnings::of(design, Some(solved)))
}
#[must_use]
pub fn tier_items_from_solved_with_warnings(
design: &Design,
solved: &[SolvedTier],
n_d: f64,
warnings: Option<&[ManufacturabilityWarning]>,
) -> Vec<TierRow> {
tier_items_from_solved_and(
design,
solved,
n_d,
&TierWarnings::from_precomputed(design, solved, warnings),
)
}
fn without_tool_checks<'a>(design: &Design, solved: &'a [SolvedTier]) -> Option<&'a [SolvedTier]> {
design.concave_tiers.is_empty().then_some(solved)
}
fn tier_items_from_solved_and(
design: &Design,
solved: &[SolvedTier],
n_d: f64,
warnings: &TierWarnings,
) -> Vec<TierRow> {
let tier_blocks = classify_blocks(&design.meet_tier_inputs());
let mm_per_unit = design.yield_report(solved).mm_per_unit;
let (_, pavilion_partner_deg) = representative_crown_and_pavilion_angles_deg(design);
let tier_labels = indicatrix_cut_core::compute_tier_labels(&design.tiers);
let row_context = RowContext {
tier_blocks: &tier_blocks,
warnings: &warnings.flat,
pavilion_partner_deg,
tier_labels: &tier_labels,
};
let mut rows: Vec<TierRow> = design
.tiers
.iter()
.enumerate()
.map(|(index, tier)| {
let (label, uncertain) = strategy_label(solved[index].strategy);
let info = TierSolveInfo {
mast: format!("{:.4}", solved[index].mast),
mast_mm: mm_per_unit.map_or_else(String::new, |mm| {
format!("{:.3} mm", solved[index].mast * mm)
}),
mast_full: format!("{}", solved[index].mast),
strategy: label.to_string(),
strategy_is_uncertain: uncertain,
strategy_detail: solved[index].detail.clone(),
needs_anchor: false,
};
build_tier_row(design, index, tier, n_d, info, &row_context)
})
.collect();
rows.extend(concave_tier_rows(design, &warnings.concave));
rows
}
const fn block_label(block: Block) -> &'static str {
match block {
Block::Crown => "Crown",
Block::Pavilion => "Pavilion",
Block::Girdle => "Girdle",
}
}