use super::number_expr::{NumberExprError, eval_number};
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::ConstraintTier;
use std::fmt;
const MAX_ANGLE_DEG: f64 = 90.0;
#[derive(Debug, Clone, PartialEq)]
pub enum StepSeriesError {
StartNotANumber(String),
StepNotANumber(String),
NotFinite,
CountOutOfRange {
count: i32,
},
AngleOutOfRange {
tier: usize,
angle_deg: f64,
},
CrossesBlock {
tier: usize,
angle_deg: f64,
},
AnchorNotANumber(String),
AnchorNotFinite,
CannotCalculate {
field: &'static str,
text: String,
reason: String,
},
}
impl fmt::Display for StepSeriesError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::StartNotANumber(text) => write!(f, "Start angle '{text}' is not a number."),
Self::StepNotANumber(text) => write!(f, "Angle step '{text}' is not a number."),
Self::NotFinite => f.write_str("Start angle and angle step must be finite numbers."),
Self::CountOutOfRange { count } => write!(
f,
"Tier count {count} is out of range -- enter a whole number from 1 to {}.",
ConstraintTier::MAX_STEP_SERIES
),
Self::AngleOutOfRange { tier, angle_deg } => write!(
f,
"Tier {tier} of the ladder would sit at {:.2}\u{b0} -- every generated \
angle must be more than 0\u{b0} and at most {MAX_ANGLE_DEG}\u{b0} from the \
girdle plane.",
angle_deg.abs()
),
Self::CrossesBlock { tier, angle_deg } => write!(
f,
"Tier {tier} of the ladder would cross the girdle (it would sit at {:.2}\u{b0} \
on the other side of the start angle's block) -- a ladder stays within one \
block (crown or pavilion).",
angle_deg.abs()
),
Self::AnchorNotANumber(text) => write!(f, "Anchor '{text}' is not a number."),
Self::AnchorNotFinite => f.write_str("Anchor must be a finite number."),
Self::CannotCalculate {
field,
text,
reason,
} => write!(f, "{field} '{text}' cannot be calculated: {reason}."),
}
}
}
impl std::error::Error for StepSeriesError {}
impl From<StepSeriesError> for String {
fn from(error: StepSeriesError) -> Self {
error.to_string()
}
}
pub fn parse_step_series_form(
start_angle_text: &str,
angle_step_text: &str,
count: i32,
anchor_text: &str,
) -> Result<(f64, f64, usize, MeetConstraint), StepSeriesError> {
let start_angle = read_field(
"Start angle",
start_angle_text,
StepSeriesError::StartNotANumber,
)?;
let angle_step = read_field(
"Angle step",
angle_step_text,
StepSeriesError::StepNotANumber,
)?;
if !start_angle.is_finite() || !angle_step.is_finite() {
return Err(StepSeriesError::NotFinite);
}
let ladder_len = usize::try_from(count)
.ok()
.filter(|&len| (1..=ConstraintTier::MAX_STEP_SERIES).contains(&len))
.ok_or(StepSeriesError::CountOutOfRange { count })?;
let anchor_text = anchor_text.trim();
let first_constraint = if anchor_text.is_empty() {
MeetConstraint::MeetExisting
} else {
let anchor = read_field("Anchor", anchor_text, StepSeriesError::AnchorNotANumber)?;
if !anchor.is_finite() {
return Err(StepSeriesError::AnchorNotFinite);
}
MeetConstraint::ScaleReference(anchor)
};
check_ladder_angles(start_angle, angle_step, ladder_len)?;
Ok((start_angle, angle_step, ladder_len, first_constraint))
}
fn read_field(
label: &'static str,
text: &str,
not_a_number: fn(String) -> StepSeriesError,
) -> Result<f64, StepSeriesError> {
eval_number(text, None).map_err(|error| match error {
NumberExprError::NotANumber => not_a_number(text.to_string()),
NumberExprError::Invalid(reason) => StepSeriesError::CannotCalculate {
field: label,
text: text.trim().to_string(),
reason,
},
})
}
fn check_ladder_angles(
start_angle: f64,
angle_step: f64,
len: usize,
) -> Result<(), StepSeriesError> {
let start_is_pavilion = start_angle.is_sign_negative();
for n in 0..len {
let angle_deg = angle_step.mul_add(n as f64, start_angle);
let magnitude = angle_deg.abs();
let within_range = magnitude > 0.0 && magnitude <= MAX_ANGLE_DEG;
if !within_range {
return Err(StepSeriesError::AngleOutOfRange {
tier: n + 1,
angle_deg,
});
}
if angle_deg.is_sign_negative() != start_is_pavilion {
return Err(StepSeriesError::CrossesBlock {
tier: n + 1,
angle_deg,
});
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_blank_anchor_means_meet_existing() {
let (start, step, count, constraint) =
parse_step_series_form("40", " 0.5 ", 3, " ").expect("parses");
assert_eq!(start.to_bits(), 40.0_f64.to_bits());
assert_eq!(step.to_bits(), 0.5_f64.to_bits());
assert_eq!(count, 3);
assert_eq!(constraint, MeetConstraint::MeetExisting);
}
#[test]
fn an_anchor_pins_the_first_tier() {
let (_, _, _, constraint) = parse_step_series_form("30", "1", 1, "0.32").expect("parses");
assert_eq!(constraint, MeetConstraint::ScaleReference(0.32));
}
#[test]
fn each_bad_field_is_named() {
assert_eq!(
parse_step_series_form("x", "1", 1, "").unwrap_err(),
StepSeriesError::StartNotANumber("x".to_string())
);
assert!(
parse_step_series_form("x", "1", 1, "")
.unwrap_err()
.to_string()
.starts_with("Start angle 'x'")
);
assert_eq!(
parse_step_series_form("30", "y", 1, "").unwrap_err(),
StepSeriesError::StepNotANumber("y".to_string())
);
assert_eq!(
parse_step_series_form("30", "1", 1, "z").unwrap_err(),
StepSeriesError::AnchorNotANumber("z".to_string())
);
assert_eq!(
parse_step_series_form("inf", "1", 1, "").unwrap_err(),
StepSeriesError::NotFinite
);
assert_eq!(
parse_step_series_form("30", "1", 1, "inf").unwrap_err(),
StepSeriesError::AnchorNotFinite
);
}
#[test]
fn the_count_is_held_to_one_through_the_cap() {
let cap = i32::try_from(ConstraintTier::MAX_STEP_SERIES).expect("the cap fits an i32");
assert!(parse_step_series_form("10", "0.5", cap, "").is_ok());
for bad in [0, -1, cap + 1, i32::MAX, i32::MIN] {
assert_eq!(
parse_step_series_form("10", "0.5", bad, "").unwrap_err(),
StepSeriesError::CountOutOfRange { count: bad },
"count {bad}"
);
}
assert!(
parse_step_series_form("10", "0.5", 0, "")
.unwrap_err()
.to_string()
.contains("1 to 64")
);
}
#[test]
fn a_crown_ladder_must_stay_above_zero_and_within_ninety() {
assert_eq!(
parse_step_series_form("40", "-10", 5, "").unwrap_err(),
StepSeriesError::AngleOutOfRange {
tier: 5,
angle_deg: 0.0
}
);
assert!(parse_step_series_form("80", "5", 3, "").is_ok());
assert_eq!(
parse_step_series_form("80", "5", 4, "").unwrap_err(),
StepSeriesError::AngleOutOfRange {
tier: 4,
angle_deg: 95.0
}
);
assert!(matches!(
parse_step_series_form("0", "1", 1, "").unwrap_err(),
StepSeriesError::AngleOutOfRange { tier: 1, .. }
));
assert!(matches!(
parse_step_series_form("91", "0", 1, "").unwrap_err(),
StepSeriesError::AngleOutOfRange { tier: 1, .. }
));
}
#[test]
fn a_pavilion_ladder_keeps_its_sign_and_the_same_limits() {
assert!(parse_step_series_form("-40", "-5", 10, "").is_ok());
assert_eq!(
parse_step_series_form("-40", "-20", 4, "").unwrap_err(),
StepSeriesError::AngleOutOfRange {
tier: 4,
angle_deg: -100.0
}
);
assert!(parse_step_series_form("-70", "-10", 3, "").is_ok());
assert!(matches!(
parse_step_series_form("-0", "0", 1, "").unwrap_err(),
StepSeriesError::AngleOutOfRange { tier: 1, .. }
));
}
#[test]
fn a_ladder_may_not_cross_into_the_other_block() {
assert_eq!(
parse_step_series_form("-40", "30", 3, "").unwrap_err(),
StepSeriesError::CrossesBlock {
tier: 3,
angle_deg: 20.0
}
);
assert_eq!(
parse_step_series_form("10", "-15", 2, "").unwrap_err(),
StepSeriesError::CrossesBlock {
tier: 2,
angle_deg: -5.0
}
);
}
#[test]
fn the_refusal_messages_show_angles_as_positive_numbers() {
let past_the_girdle = parse_step_series_form("-40", "-20", 4, "").unwrap_err();
assert_eq!(
past_the_girdle.to_string(),
"Tier 4 of the ladder would sit at 100.00\u{b0} -- every generated angle must be \
more than 0\u{b0} and at most 90\u{b0} from the girdle plane."
);
let across = parse_step_series_form("10", "-15", 2, "").unwrap_err();
assert_eq!(
across.to_string(),
"Tier 2 of the ladder would cross the girdle (it would sit at 5.00\u{b0} on the \
other side of the start angle's block) -- a ladder stays within one block (crown \
or pavilion)."
);
}
#[test]
fn the_numeric_fields_take_arithmetic() {
let (start, step, count, constraint) =
parse_step_series_form("40 + 2", " -(1 / 2) ", 3, "0.3 + 0.02").expect("parses");
assert_eq!(start.to_bits(), 42.0_f64.to_bits());
assert_eq!(step.to_bits(), (-0.5_f64).to_bits());
assert_eq!(count, 3);
assert_eq!(constraint, MeetConstraint::ScaleReference(0.32));
}
#[test]
fn a_calculation_that_fails_names_its_field() {
let error = parse_step_series_form("40", "1 / 0", 3, "").unwrap_err();
assert_eq!(
error.to_string(),
"Angle step '1 / 0' cannot be calculated: it divides by zero."
);
let error = parse_step_series_form("40", "1", 3, "(2").unwrap_err();
assert!(
error
.to_string()
.starts_with("Anchor '(2' cannot be calculated:"),
"{error}"
);
let error = parse_step_series_form("4 0 +", "1", 3, "").unwrap_err();
assert!(
error.to_string().starts_with("Start angle '4 0 +'"),
"{error}"
);
}
#[test]
fn the_error_text_converts_to_a_string() {
let message: String = StepSeriesError::NotFinite.into();
assert_eq!(
message,
"Start angle and angle step must be finite numbers."
);
}
}