vct_finish_layer_count_2026/

lib.rs

//! VCT Finish Layer Count 2026 — Rust Engine
//!
//! Burnishing response, repairability, and COF/slip compliance calculator
//! for commercial VCT floor maintenance programs.
//!
//! Reference: <https://www.binx.ca/guides/vct-finish-layer-count-optimization-2026.pdf>

use std::collections::HashMap;

/// Finish formulation type
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum FinishType {
    AcrylicZinc,
    AcrylicNoMetal,
    HighSolids,
}

impl FinishType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::AcrylicZinc => "acrylic_zinc",
            Self::AcrylicNoMetal => "acrylic_no_metal",
            Self::HighSolids => "high_solids",
        }
    }
}

/// Floor traffic level
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TrafficLevel {
    Low,
    Medium,
    High,
    Extreme,
}

impl TrafficLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
            Self::Extreme => "extreme",
        }
    }
}

/// Zone type for COF compliance threshold selection
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ZoneType {
    DryGeneral,
    WetGeneral,
    AccessibleRoute,
    HealthcareWet,
}

/// Burnishing response assessment
#[derive(Debug, Clone)]
pub struct BurnishResponse {
    pub gloss_initial: u32,
    pub gloss_1pass: u32,
    pub gloss_3pass: u32,
    pub rating: String,
    pub heat_risk: String,
}

/// Repairability assessment
#[derive(Debug, Clone)]
pub struct RepairabilityResult {
    pub score: u32,
    pub spot_repair_viable: bool,
    pub strip_required: bool,
    pub strip_difficulty: String,
    pub strip_time_per_1000sqft: u32,
}

/// Program recommendation
#[derive(Debug, Clone)]
pub struct Recommendation {
    pub action: String,
    pub optimal_range: (u32, u32),
    pub coats_to_strip_trigger: u32,
    pub notes: String,
}

/// Full coat count assessment result
#[derive(Debug, Clone)]
pub struct CoatCountResult {
    pub finish_type: String,
    pub traffic_level: String,
    pub coat_count: u32,
    pub burnish_response: BurnishResponse,
    pub repairability: RepairabilityResult,
    pub recommendation: Recommendation,
}

/// COF compliance result
#[derive(Debug, Clone)]
pub struct CofResult {
    pub finish_type: String,
    pub coat_count: u32,
    pub zone_type: String,
    pub static_cof_dry: f64,
    pub static_cof_wet: f64,
    pub passes_osha_dry: bool,
    pub passes_nfpa_wet: bool,
    pub passes_csa_accessible: bool,
    pub passes_obc_healthcare: bool,
    pub slip_risk_rating: String,
    pub action_required: String,
}

fn burnish_data() -> HashMap<(&'static str, u32), (u32, u32, u32, u32)> {
    let mut m = HashMap::new();
    // acrylic_zinc
    for (c, v) in [
        (1,(12,18,22,0)),(2,(22,30,34,0)),(3,(34,52,60,0)),(4,(42,64,74,0)),
        (5,(48,72,82,0)),(6,(52,78,88,0)),(7,(54,80,90,0)),(8,(54,80,89,1)),
        (9,(53,79,87,1)),(10,(51,75,82,2)),(11,(48,68,74,2)),(12,(44,60,66,2)),
        (13,(40,54,59,3)),(14,(38,50,55,3)),
    ] { m.insert(("acrylic_zinc", c), v); }
    // acrylic_no_metal
    for (c, v) in [
        (1,(10,15,18,0)),(2,(18,26,30,0)),(3,(28,44,52,0)),(4,(36,56,66,0)),
        (5,(42,64,74,0)),(6,(44,68,78,0)),(7,(46,70,80,0)),(8,(44,68,76,1)),
        (9,(42,64,72,1)),(10,(40,60,66,2)),(11,(36,54,58,2)),(12,(32,46,50,3)),
    ] { m.insert(("acrylic_no_metal", c), v); }
    // high_solids
    for (c, v) in [
        (1,(18,26,30,0)),(2,(30,48,58,0)),(3,(46,70,82,0)),(4,(54,82,92,0)),
        (5,(56,84,94,1)),(6,(54,80,88,1)),(7,(50,72,80,2)),(8,(46,66,72,2)),
        (9,(40,56,62,3)),(10,(34,48,52,3)),
    ] { m.insert(("high_solids", c), v); }
    m
}

fn optimal_ranges() -> HashMap<(&'static str, &'static str), (u32, u32, u32)> {
    let mut m = HashMap::new();
    for (k, v) in [
        (("acrylic_zinc","low"),(3,5,8)),(("acrylic_zinc","medium"),(5,6,9)),
        (("acrylic_zinc","high"),(6,7,10)),(("acrylic_zinc","extreme"),(7,7,10)),
        (("acrylic_no_metal","low"),(3,4,8)),(("acrylic_no_metal","medium"),(5,6,9)),
        (("acrylic_no_metal","high"),(6,7,10)),(("acrylic_no_metal","extreme"),(6,7,10)),
        (("high_solids","low"),(2,3,6)),(("high_solids","medium"),(3,4,7)),
        (("high_solids","high"),(4,5,8)),(("high_solids","extreme"),(4,5,8)),
    ] { m.insert(k, v); }
    m
}

fn repair_scores() -> HashMap<u32, (u32, bool, bool, &'static str, u32)> {
    let mut m = HashMap::new();
    for (c, v) in [
        (1,(1,false,true,"easy",18)),(2,(3,false,true,"easy",20)),
        (3,(6,true,false,"easy",22)),(4,(8,true,false,"easy",24)),
        (5,(9,true,false,"easy",26)),(6,(9,true,false,"moderate",30)),
        (7,(8,true,false,"moderate",34)),(8,(6,true,false,"moderate",38)),
        (9,(4,false,true,"hard",45)),(10,(2,false,true,"hard",52)),
        (11,(2,false,true,"very_hard",60)),(12,(1,false,true,"very_hard",65)),
        (13,(1,false,true,"extreme",78)),(14,(1,false,true,"extreme",85)),
        (15,(1,false,true,"extreme",100)),
    ] { m.insert(c, v); }
    m
}

fn cof_data() -> HashMap<(&'static str, u32), (f64, f64)> {
    let mut m = HashMap::new();
    for (c, v) in [
        (0,(0.62,0.55)),(1,(0.58,0.50)),(2,(0.56,0.47)),(3,(0.55,0.45)),
        (4,(0.54,0.44)),(5,(0.52,0.42)),(6,(0.51,0.40)),(7,(0.50,0.39)),
        (8,(0.49,0.37)),(9,(0.48,0.36)),(10,(0.47,0.35)),
    ] { m.insert(("acrylic_zinc", c), v); }
    for (c, v) in [
        (0,(0.63,0.56)),(1,(0.60,0.52)),(2,(0.58,0.50)),(3,(0.57,0.48)),
        (4,(0.56,0.47)),(5,(0.54,0.45)),(6,(0.53,0.43)),(7,(0.51,0.41)),
        (8,(0.50,0.39)),(9,(0.49,0.38)),(10,(0.48,0.37)),
    ] { m.insert(("acrylic_no_metal", c), v); }
    for (c, v) in [
        (0,(0.62,0.55)),(1,(0.57,0.49)),(2,(0.55,0.46)),(3,(0.53,0.43)),
        (4,(0.51,0.41)),(5,(0.50,0.39)),(6,(0.49,0.37)),(7,(0.47,0.35)),
        (8,(0.46,0.34)),
    ] { m.insert(("high_solids", c), v); }
    m
}

fn clamp_to_nearest(available: &[u32], n: u32) -> u32 {
    *available.iter().min_by_key(|&&k| (k as i32 - n as i32).unsigned_abs()).unwrap_or(&1)
}

fn burnish_rating(g3: u32) -> &'static str {
    if g3 >= 85 { "excellent" } else if g3 >= 70 { "good" } else if g3 >= 55 { "fair" } else { "poor" }
}

/// Assess a VCT finish coat count program.
pub fn assess_coat_count(
    finish_type: FinishType,
    traffic_level: TrafficLevel,
    coat_count: u32,
) -> CoatCountResult {
    let ft = finish_type.as_str();
    let tl = traffic_level.as_str();
    let heat_labels = ["low", "medium", "high", "very_high"];
    let bd = burnish_data();
    let available_b: Vec<u32> = bd.keys().filter(|(f,_)| *f == ft).map(|(_,c)| *c).collect();
    let bkey = clamp_to_nearest(&available_b, coat_count);
    let (gi, g1, g3, hri) = bd[&(ft, bkey)];

    let rs = repair_scores();
    let available_r: Vec<u32> = rs.keys().cloned().collect();
    let rkey = clamp_to_nearest(&available_r, coat_count.min(15).max(1));
    let (score, spot, strip, diff, stime) = rs[&rkey];

    let or_map = optimal_ranges();
    let (mn, mx, trigger) = or_map.get(&(ft, tl)).copied().unwrap_or((4, 7, 10));
    let to_trigger = trigger.saturating_sub(coat_count);

    let (action, notes) = if coat_count < mn {
        ("add_coats".to_string(), format!("Floor is under-coated. Optimal range for {} traffic ({}) is {}–{} coats. Add {} coat(s) before next burnish.", tl, ft, mn, mx, mn - coat_count))
    } else if coat_count <= mx {
        ("maintain".to_string(), format!("Coat count is within optimal range ({}–{}) for {} traffic. Strip cycle triggered at {} coats ({} remaining). Continue scheduled program.", mn, mx, tl, trigger, to_trigger))
    } else if coat_count < trigger {
        ("plan_strip".to_string(), format!("Coat count exceeds optimal range. Schedule strip-and-refinish within next maintenance cycle. {} coats remaining before strip trigger.", to_trigger))
    } else {
        ("strip_now".to_string(), format!("Strip trigger reached ({} coats). Full strip cycle required. Expect {} strip ({} min/1,000 sq ft).", coat_count, diff, stime))
    };

    CoatCountResult {
        finish_type: ft.to_string(),
        traffic_level: tl.to_string(),
        coat_count,
        burnish_response: BurnishResponse {
            gloss_initial: gi, gloss_1pass: g1, gloss_3pass: g3,
            rating: burnish_rating(g3).to_string(),
            heat_risk: heat_labels[hri as usize].to_string(),
        },
        repairability: RepairabilityResult {
            score, spot_repair_viable: spot, strip_required: strip,
            strip_difficulty: diff.to_string(), strip_time_per_1000sqft: stime,
        },
        recommendation: Recommendation {
            action, optimal_range: (mn, mx), coats_to_strip_trigger: to_trigger, notes,
        },
    }
}

/// Assess COF compliance for a finished VCT floor.
pub fn assess_cof(
    finish_type: FinishType,
    coat_count: u32,
    zone_type: ZoneType,
) -> CofResult {
    let ft = finish_type.as_str();
    let zt_str = match zone_type {
        ZoneType::DryGeneral => "dry_general",
        ZoneType::WetGeneral => "wet_general",
        ZoneType::AccessibleRoute => "accessible_route",
        ZoneType::HealthcareWet => "healthcare_wet",
    };
    let cd = cof_data();
    let available_c: Vec<u32> = cd.keys().filter(|(f,_)| *f == ft).map(|(_,c)| *c).collect();
    let ckey = clamp_to_nearest(&available_c, coat_count);
    let (dry, wet) = cd[&(ft, ckey)];

    let high_zone = matches!(zone_type, ZoneType::AccessibleRoute | ZoneType::HealthcareWet);
    let wet_thresh = if high_zone { 0.60 } else { 0.50 };
    let diff = wet - wet_thresh;
    let slip_risk = if diff >= 0.08 { "low" } else if diff >= 0.02 { "medium" } else if diff >= -0.02 { "medium_high" } else if diff >= -0.08 { "high" } else { "very_high" };
    let threshold_met = if high_zone { wet >= 0.60 } else { wet >= 0.50 };
    let action = if threshold_met && dry >= 0.50 { "none" } else if dry >= 0.50 && wet >= 0.44 { "monitor" } else if coat_count >= 9 { "strip_and_retreat" } else { "anti_slip_treatment_required" };

    CofResult {
        finish_type: ft.to_string(), coat_count, zone_type: zt_str.to_string(),
        static_cof_dry: (dry * 100.0).round() / 100.0,
        static_cof_wet: (wet * 100.0).round() / 100.0,
        passes_osha_dry: dry >= 0.50, passes_nfpa_wet: wet >= 0.50,
        passes_csa_accessible: dry >= 0.60, passes_obc_healthcare: wet >= 0.60,
        slip_risk_rating: slip_risk.to_string(), action_required: action.to_string(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn medium_traffic_5coats_is_maintain() {
        let r = assess_coat_count(FinishType::AcrylicZinc, TrafficLevel::Medium, 5);
        assert_eq!(r.recommendation.action, "maintain");
        assert_eq!(r.burnish_response.rating, "good");
        assert_eq!(r.repairability.score, 9);
    }
    #[test]
    fn high_coats_triggers_strip() {
        let r = assess_coat_count(FinishType::AcrylicZinc, TrafficLevel::Medium, 10);
        assert_eq!(r.recommendation.action, "strip_now");
    }
    #[test]
    fn wet_zone_fails_nfpa_at_6_coats() {
        let r = assess_cof(FinishType::AcrylicZinc, 6, ZoneType::WetGeneral);
        assert!(!r.passes_nfpa_wet);
        assert_eq!(r.action_required, "anti_slip_treatment_required");
    }
}