use super::{
CrownShift, PlanRow, RetargetError, RetargetMode, RetargetPlan, RetargetProposal, RetargetRow,
check::RetargetCheck, plan::tier_display_names, validity::ValidityStatus,
};
use crate::{
material::{
design_material_index_from_name, design_material_options, parse_design_material_form,
},
material_lookup::{EditorMaterialLookup, resolved_gem_material},
};
use indicatrix::{geometry::meet_solver::Block, optics::materials::GemMaterial};
use indicatrix_cut_core::{
Design, MaterialSelection, ResolvedMaterial, Risk, optics_hints::AngleGuard,
};
pub const NOT_CHANGED_LABEL: &str = "Not changed";
pub const FOLLOWS_LABEL: &str = "Follows";
pub const OPTIMIZE_HINT: &str = "Shift alone is not valid here. Use Optimize: it also adjusts the crown and pavilion angles within a range you choose.";
pub const NO_VALUE: &str = "\u{2014}";
#[derive(Debug, Clone)]
pub struct RetargetRowView {
pub tier_index: usize,
pub block: &'static str,
pub name: String,
pub old_angle: String,
pub new_angle: String,
pub margin: String,
pub risk_label: &'static str,
pub risk_rgb: (u8, u8, u8),
pub changed: bool,
}
#[derive(Debug, Clone, Default)]
pub struct RetargetView {
pub rows: Vec<RetargetRowView>,
pub notes: Vec<String>,
pub anchored_errors: Vec<String>,
pub solve_error: String,
}
impl RetargetView {
#[must_use]
pub fn with_tier_names(mut self, design: &Design) -> Self {
let names = tier_display_names(design);
for row in &mut self.rows {
if let Some(name) = names.get(row.tier_index) {
row.name.clone_from(name);
}
}
self
}
}
fn angle_text(angle_deg: f64) -> String {
format!("{:.2}\u{b0}", angle_deg.abs())
}
#[must_use]
pub const fn risk_label_and_rgb(risk: Risk) -> (&'static str, (u8, u8, u8)) {
match risk {
Risk::Safe => ("Safe", (0x10, 0xb9, 0x81)),
Risk::Marginal => ("Marginal", (0xf5, 0x9e, 0x0b)),
Risk::Windows => ("Windows", (0xf4, 0x3f, 0x5e)),
}
}
#[must_use]
pub fn row_view(row: &RetargetRow) -> RetargetRowView {
let block = match row.block {
Block::Crown => "Crown",
Block::Pavilion => "Pavilion",
Block::Girdle => "Girdle",
};
let (risk_label, risk_rgb) = risk_label_and_rgb(row.risk);
RetargetRowView {
tier_index: row.tier_index,
block,
name: row.name.clone(),
old_angle: angle_text(row.old_angle),
new_angle: angle_text(row.new_angle),
margin: format!("{:+.2}\u{b0}", row.margin_deg),
risk_label,
risk_rgb,
changed: true,
}
}
#[must_use]
pub fn plan_row_view(row: &PlanRow) -> RetargetRowView {
let block = match row.block {
Block::Crown => "Crown",
Block::Pavilion => "Pavilion",
Block::Girdle => "Girdle",
};
let held = if row.guard == AngleGuard::Within {
""
} else {
" (held)"
};
let new_angle = format!("{}{held}", angle_text(row.new_angle));
let old_angle = angle_text(row.old_angle);
if let Some(relation) = &row.follows {
return RetargetRowView {
tier_index: row.tier_index,
block,
name: row.name.clone(),
old_angle,
new_angle,
margin: format!("= {relation}"),
risk_label: FOLLOWS_LABEL,
risk_rgb: (0, 0, 0),
changed: (row.new_angle - row.old_angle).abs() > 1e-9,
};
}
if !row.moves {
return RetargetRowView {
tier_index: row.tier_index,
block,
name: row.name.clone(),
old_angle,
new_angle,
margin: NO_VALUE.to_string(),
risk_label: NOT_CHANGED_LABEL,
risk_rgb: (0, 0, 0),
changed: false,
};
}
let (margin, risk_label, risk_rgb) = match (row.margin_deg, row.risk) {
(Some(margin), Some(risk)) => {
let (label, rgb) = risk_label_and_rgb(risk);
let suffix = if row.margin_is_estimate { " est." } else { "" };
(format!("{margin:+.2}\u{b0}{suffix}"), label, rgb)
}
_ => (NO_VALUE.to_string(), NO_VALUE, (0, 0, 0)),
};
RetargetRowView {
tier_index: row.tier_index,
block,
name: row.name.clone(),
old_angle,
new_angle,
margin,
risk_label,
risk_rgb,
changed: true,
}
}
#[must_use]
pub fn plan_view(plan: &RetargetPlan) -> RetargetView {
RetargetView {
rows: plan.rows.iter().map(plan_row_view).collect(),
notes: plan.notes.clone(),
anchored_errors: Vec::new(),
solve_error: String::new(),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CheckState {
#[default]
None,
Checking,
Valid,
Invalid,
Unchecked,
}
impl CheckState {
#[must_use]
pub const fn code(self) -> i32 {
match self {
Self::None => 0,
Self::Checking => 1,
Self::Valid => 2,
Self::Invalid => 3,
Self::Unchecked => 4,
}
}
#[must_use]
pub const fn allows_apply(self) -> bool {
matches!(self, Self::None | Self::Valid | Self::Unchecked)
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CheckView {
pub state: CheckState,
pub headline: String,
pub details: Vec<String>,
pub strategy: String,
pub metrics: Vec<String>,
}
impl CheckView {
#[must_use]
pub fn checking() -> Self {
Self {
state: CheckState::Checking,
headline: "Checking...".to_string(),
..Self::default()
}
}
#[must_use]
pub fn with_optimize_hint(mut self) -> Self {
if self.state == CheckState::Invalid {
self.details.push(OPTIMIZE_HINT.to_string());
}
self
}
#[must_use]
pub fn from_check(check: &RetargetCheck) -> Self {
let state = match check.validity.status {
ValidityStatus::Valid => CheckState::Valid,
ValidityStatus::Invalid => CheckState::Invalid,
ValidityStatus::Unchecked => CheckState::Unchecked,
};
let metrics = if check.metrics.any() {
check.metrics.cells()
} else {
Vec::new()
};
Self {
state,
headline: check.validity.headline(),
details: check.validity.detail_lines(),
strategy: check.validity.strategy.label().to_string(),
metrics,
}
}
}
#[must_use]
pub fn retarget_view(
design: &Design,
target: &ResolvedMaterial,
crown: CrownShift,
mode: RetargetMode,
custom_materials: &[GemMaterial],
) -> (RetargetView, Option<RetargetProposal>) {
match super::build_proposal(design, target, crown, mode, custom_materials) {
Ok(proposal) => {
let rows = proposal.rows.iter().map(row_view).collect();
let view = RetargetView {
rows,
notes: proposal.notes.clone(),
anchored_errors: Vec::new(),
solve_error: String::new(),
}
.with_tier_names(design);
(view, Some(proposal))
}
Err(RetargetError::AnchoredTiers(tiers)) => {
let anchored_errors = tiers
.iter()
.map(|(index, name)| format!("#{index} \"{name}\""))
.collect();
let view = RetargetView {
rows: Vec::new(),
notes: Vec::new(),
anchored_errors,
solve_error: String::new(),
};
(view, None)
}
Err(RetargetError::Solve(err)) => {
let view = RetargetView {
rows: Vec::new(),
notes: Vec::new(),
anchored_errors: Vec::new(),
solve_error: err.to_string(),
};
(view, None)
}
}
}
pub fn resolve_target_selection(
design: &Design,
custom: &[GemMaterial],
combo_index: i32,
ri_override_text: &str,
) -> Result<MaterialSelection, String> {
let options = design_material_options(custom);
parse_design_material_form(combo_index, ri_override_text, &options, &design.material)
}
#[must_use]
pub fn target_material_selection(
design: &Design,
custom: &[GemMaterial],
combo_index: i32,
ri_override_text: &str,
) -> MaterialSelection {
resolve_target_selection(design, custom, combo_index, ri_override_text)
.unwrap_or_else(|_| design.material.clone())
}
#[must_use]
pub fn resolved_material_from_selection(
selection: &MaterialSelection,
custom: &[GemMaterial],
) -> ResolvedMaterial {
let lookup = EditorMaterialLookup::new(custom);
let resolved = selection.resolve(&lookup);
let gem = resolved_gem_material(selection, &lookup);
ResolvedMaterial { gem, ..resolved }
}
#[must_use]
pub fn target_display_name(selection: &MaterialSelection) -> String {
selection.name.clone().unwrap_or_else(|| {
if selection.refractive_index_override.is_some() {
"Custom RI".to_string()
} else {
"(none)".to_string()
}
})
}
#[must_use]
pub fn initial_target_index(material: &MaterialSelection, options: &[String]) -> i32 {
if material.name.is_none() && material.refractive_index_override.is_some() {
return i32::try_from(options.len()).unwrap_or(i32::MAX) - 1;
}
design_material_index_from_name(material.name.as_deref(), options)
}