pub mod steps;
#[cfg(test)]
mod tests;
pub use steps::{ALL_GROUPS, EIGHT_FOLD_INDICES, Group, STEPS, Step};
use indicatrix_cut_core::Design;
pub const MANUAL: &str = "manual";
pub const NEW_DESIGN_CREATED: &str = "new_design_created";
const ANGLE_TOLERANCE_DEG: f64 = 0.05;
const INDEX_TOLERANCE: f64 = 1e-6;
#[must_use]
pub fn goal_reached(key: &str, design: &Design, solved_closed: bool) -> bool {
match key {
"material:Diamond" => design
.material
.name
.as_deref()
.is_some_and(|name| name.trim().eq_ignore_ascii_case("Diamond")),
"solved_closed" => solved_closed && !design.tiers.is_empty(),
"yield_applied" => design.girdle_diameter_mm.is_some(),
NEW_DESIGN_CREATED => false,
_ => key
.strip_prefix("tier_named:")
.is_some_and(|name| has_expected_tier(design, name)),
}
}
#[must_use]
pub fn reached_completion(
step_index: usize,
design: &Design,
solved_closed: bool,
) -> Option<&'static str> {
let step = STEPS.get(step_index)?;
goal_reached(step.completion, design, solved_closed).then_some(step.completion)
}
fn expected_tier(name: &str) -> Option<(f64, &'static [f64])> {
match name {
"G1" => Some((90.0, &EIGHT_FOLD_INDICES)),
"P1" => Some((-40.0, &EIGHT_FOLD_INDICES)),
"C1" => Some((34.5, &EIGHT_FOLD_INDICES)),
"T" => Some((0.0, &[])),
_ => None,
}
}
fn has_expected_tier(design: &Design, name: &str) -> bool {
let Some((angle, indices)) = expected_tier(name) else {
return false;
};
let gear = f64::from(design.meta.gear_teeth_abs());
design.tiers.iter().any(|tier| {
tier.names()
.into_iter()
.any(|n| n.trim().eq_ignore_ascii_case(name))
&& (tier.angle_deg - angle).abs() <= ANGLE_TOLERANCE_DEG
&& same_index_set(&tier.indices, indices, gear)
})
}
#[must_use]
pub fn same_index_set(actual: &[f64], expected: &[f64], gear: f64) -> bool {
let same = |a: f64, b: f64| {
if gear > 0.0 {
let d = (a - b).rem_euclid(gear);
d.min(gear - d) <= INDEX_TOLERANCE
} else {
(a - b).abs() <= INDEX_TOLERANCE
}
};
if expected.is_empty() {
return match actual {
[] => true,
[only] => same(*only, 0.0),
_ => false,
};
}
actual.len() == expected.len()
&& expected.iter().all(|&e| actual.iter().any(|&a| same(a, e)))
&& actual.iter().all(|&a| expected.iter().any(|&e| same(a, e)))
}