use super::without_tool_checks;
use indicatrix::geometry::meet_solver::SolvedTier;
use indicatrix_cut_core::{Design, ManufacturabilityWarning};
use std::collections::BTreeMap;
pub(super) struct TierWarnings {
pub(super) flat: BTreeMap<usize, String>,
pub(super) concave: BTreeMap<usize, String>,
}
impl TierWarnings {
pub(super) fn of(design: &Design, solved: Option<&[SolvedTier]>) -> Self {
Self::from_findings(tagged_findings(design, solved))
}
pub(super) fn from_precomputed(
design: &Design,
solved: &[SolvedTier],
precomputed: Option<&[ManufacturabilityWarning]>,
) -> Self {
precomputed.map_or_else(
|| Self::of(design, without_tool_checks(design, solved)),
|warnings| Self::from_findings(findings_of(warnings)),
)
}
fn from_findings(findings: Vec<Finding>) -> Self {
let (mut flat, mut concave) = (Vec::new(), Vec::new());
for finding in findings {
match finding.target {
WarningTarget::Flat(index) => flat.push((index, finding.text)),
WarningTarget::Concave(index) => concave.push((index, finding.text)),
WarningTarget::Design => {}
}
}
Self {
flat: warning_text_by_tier(&flat),
concave: warning_text_by_tier(&concave),
}
}
}
enum WarningTarget {
Flat(usize),
Concave(usize),
Design,
}
struct Finding {
target: WarningTarget,
text: String,
}
fn manufacturability_findings(design: &Design, solved: Option<&[SolvedTier]>) -> Vec<Finding> {
findings_of(
&indicatrix_cut_core::manufacturability::check_manufacturability_available(
design,
solved,
indicatrix_cut_core::manufacturability::DEFAULT_MIN_FACET_AREA_FRACTION_OF_W2,
),
)
}
fn findings_of(warnings: &[ManufacturabilityWarning]) -> Vec<Finding> {
warnings
.iter()
.map(|warning| Finding {
target: match (warning, warning.concave_tier()) {
(_, Some(tier)) => WarningTarget::Concave(tier),
(
ManufacturabilityWarning::VanishingFacet { .. }
| ManufacturabilityWarning::UndersizedFacet { .. }
| ManufacturabilityWarning::FractionalIndex { .. }
| ManufacturabilityWarning::OutOfOrderMeet { .. }
| ManufacturabilityWarning::MeetNameNotAscSafe { .. },
None,
) => WarningTarget::Flat(warning.tier_index()),
(_, None) => WarningTarget::Design,
},
text: warning.to_string(),
})
.collect()
}
#[must_use]
pub fn solved_manufacturability_warnings(
design: &Design,
solved: &[SolvedTier],
) -> Vec<ManufacturabilityWarning> {
indicatrix_cut_core::manufacturability::check_manufacturability_available(
design,
Some(solved),
indicatrix_cut_core::manufacturability::DEFAULT_MIN_FACET_AREA_FRACTION_OF_W2,
)
}
fn tagged_findings(design: &Design, solved: Option<&[SolvedTier]>) -> Vec<Finding> {
let findings = manufacturability_findings(design, solved);
if solved.is_some() {
return findings;
}
findings
.into_iter()
.map(|finding| Finding {
text: format!("(pre-solve) {}", finding.text),
..finding
})
.collect()
}
#[must_use]
pub fn manufacturability_warnings_tagged(
design: &Design,
solved: Option<&[SolvedTier]>,
) -> Vec<(usize, String)> {
tagged_findings(design, solved)
.into_iter()
.filter_map(|finding| match finding.target {
WarningTarget::Flat(index) => Some((index, finding.text)),
WarningTarget::Concave(_) | WarningTarget::Design => None,
})
.collect()
}
#[must_use]
pub fn manufacturability_warnings_tagged_with(
design: &Design,
solved: &[SolvedTier],
warnings: Option<&[ManufacturabilityWarning]>,
) -> Vec<(usize, String)> {
let Some(warnings) = warnings else {
return manufacturability_warnings_tagged(design, without_tool_checks(design, solved));
};
findings_of(warnings)
.into_iter()
.filter_map(|finding| match finding.target {
WarningTarget::Flat(index) => Some((index, finding.text)),
WarningTarget::Concave(_) | WarningTarget::Design => None,
})
.collect()
}
fn warning_text_by_tier(pairs: &[(usize, String)]) -> BTreeMap<usize, String> {
let mut grouped: BTreeMap<usize, Vec<String>> = BTreeMap::new();
for (tier_index, text) in pairs {
grouped.entry(*tier_index).or_default().push(text.clone());
}
grouped
.into_iter()
.map(|(index, texts)| (index, texts.join("; ")))
.collect()
}