acadrust 0.6.2

//! AutoCAD Color Index (ACI) to RGB lookup table.
//!
//! The canonical 256-entry mapping used by AutoCAD.  Indices 0 (ByBlock) and
//! 256 (ByLayer) are _not_ real colors; index 7 is white on dark backgrounds
//! and black on light backgrounds, mapped here as (255,255,255).
//!
//! Source: AutoCAD Color Index specification, matching ezdxf / LibreCAD tables.

/// RGB tuple for a single ACI entry.
type Rgb = (u8, u8, u8);

/// The standard 256-entry AutoCAD Color Index table (indices 0–255).
///
/// Index 0 maps to (0,0,0) as a placeholder — real usage treats it as ByBlock.
pub static ACI_COLORS: [Rgb; 256] = [
    // 0: ByBlock placeholder
    (0, 0, 0),
    // 1–9: standard colors
    (255, 0, 0),     // 1  Red
    (255, 255, 0),   // 2  Yellow
    (0, 255, 0),     // 3  Green
    (0, 255, 255),   // 4  Cyan
    (0, 0, 255),     // 5  Blue
    (255, 0, 255),   // 6  Magenta
    (255, 255, 255), // 7  White (or Black depending on background)
    (128, 128, 128), // 8  Dark gray
    (192, 192, 192), // 9  Light gray
    // 10–19
    (255, 0, 0),     // 10
    (255, 127, 127), // 11
    (165, 0, 0),     // 12
    (165, 82, 82),   // 13
    (127, 0, 0),     // 14
    (127, 63, 63),   // 15
    (76, 0, 0),      // 16
    (76, 38, 38),    // 17
    (38, 0, 0),      // 18
    (38, 19, 19),    // 19
    // 20–29
    (255, 63, 0),    // 20
    (255, 159, 127), // 21
    (165, 41, 0),    // 22
    (165, 103, 82),  // 23
    (127, 31, 0),    // 24
    (127, 79, 63),   // 25
    (76, 19, 0),     // 26
    (76, 47, 38),    // 27
    (38, 9, 0),      // 28
    (38, 23, 19),    // 29
    // 30–39
    (255, 127, 0),   // 30
    (255, 191, 127), // 31
    (165, 82, 0),    // 32
    (165, 124, 82),  // 33
    (127, 63, 0),    // 34
    (127, 95, 63),   // 35
    (76, 38, 0),     // 36
    (76, 57, 38),    // 37
    (38, 19, 0),     // 38
    (38, 28, 19),    // 39
    // 40–49
    (255, 191, 0),   // 40
    (255, 223, 127), // 41
    (165, 124, 0),   // 42
    (165, 145, 82),  // 43
    (127, 95, 0),    // 44
    (127, 111, 63),  // 45
    (76, 57, 0),     // 46
    (76, 66, 38),    // 47
    (38, 28, 0),     // 48
    (38, 33, 19),    // 49
    // 50–59
    (255, 255, 0),   // 50
    (255, 255, 127), // 51
    (165, 165, 0),   // 52
    (165, 165, 82),  // 53
    (127, 127, 0),   // 54
    (127, 127, 63),  // 55
    (76, 76, 0),     // 56
    (76, 76, 38),    // 57
    (38, 38, 0),     // 58
    (38, 38, 19),    // 59
    // 60–69
    (191, 255, 0),   // 60
    (223, 255, 127), // 61
    (124, 165, 0),   // 62
    (145, 165, 82),  // 63
    (95, 127, 0),    // 64
    (111, 127, 63),  // 65
    (57, 76, 0),     // 66
    (66, 76, 38),    // 67
    (28, 38, 0),     // 68
    (33, 38, 19),    // 69
    // 70–79
    (127, 255, 0),   // 70
    (191, 255, 127), // 71
    (82, 165, 0),    // 72
    (124, 165, 82),  // 73
    (63, 127, 0),    // 74
    (95, 127, 63),   // 75
    (38, 76, 0),     // 76
    (57, 76, 38),    // 77
    (19, 38, 0),     // 78
    (28, 38, 19),    // 79
    // 80–89
    (63, 255, 0),    // 80
    (159, 255, 127), // 81
    (41, 165, 0),    // 82
    (103, 165, 82),  // 83
    (31, 127, 0),    // 84
    (79, 127, 63),   // 85
    (19, 76, 0),     // 86
    (47, 76, 38),    // 87
    (9, 38, 0),      // 88
    (23, 38, 19),    // 89
    // 90–99
    (0, 255, 0),     // 90
    (127, 255, 127), // 91
    (0, 165, 0),     // 92
    (82, 165, 82),   // 93
    (0, 127, 0),     // 94
    (63, 127, 63),   // 95
    (0, 76, 0),      // 96
    (38, 76, 38),    // 97
    (0, 38, 0),      // 98
    (19, 38, 19),    // 99
    // 100–109
    (0, 255, 63),    // 100
    (127, 255, 159), // 101
    (0, 165, 41),    // 102
    (82, 165, 103),  // 103
    (0, 127, 31),    // 104
    (63, 127, 79),   // 105
    (0, 76, 19),     // 106
    (38, 76, 47),    // 107
    (0, 38, 9),      // 108
    (19, 38, 23),    // 109
    // 110–119
    (0, 255, 127),   // 110
    (127, 255, 191), // 111
    (0, 165, 82),    // 112
    (82, 165, 124),  // 113
    (0, 127, 63),    // 114
    (63, 127, 95),   // 115
    (0, 76, 38),     // 116
    (38, 76, 57),    // 117
    (0, 38, 19),     // 118
    (19, 38, 28),    // 119
    // 120–129
    (0, 255, 191),   // 120
    (127, 255, 223), // 121
    (0, 165, 124),   // 122
    (82, 165, 145),  // 123
    (0, 127, 95),    // 124
    (63, 127, 111),  // 125
    (0, 76, 57),     // 126
    (38, 76, 66),    // 127
    (0, 38, 28),     // 128
    (19, 38, 33),    // 129
    // 130–139
    (0, 255, 255),   // 130
    (127, 255, 255), // 131
    (0, 165, 165),   // 132
    (82, 165, 165),  // 133
    (0, 127, 127),   // 134
    (63, 127, 127),  // 135
    (0, 76, 76),     // 136
    (38, 76, 76),    // 137
    (0, 38, 38),     // 138
    (19, 38, 38),    // 139
    // 140–149
    (0, 191, 255),   // 140
    (127, 223, 255), // 141
    (0, 124, 165),   // 142
    (82, 145, 165),  // 143
    (0, 95, 127),    // 144
    (63, 111, 127),  // 145
    (0, 57, 76),     // 146
    (38, 66, 76),    // 147
    (0, 28, 38),     // 148
    (19, 33, 38),    // 149
    // 150–159
    (0, 127, 255),   // 150
    (127, 191, 255), // 151
    (0, 82, 165),    // 152
    (82, 124, 165),  // 153
    (0, 63, 127),    // 154
    (63, 95, 127),   // 155
    (0, 38, 76),     // 156
    (38, 57, 76),    // 157
    (0, 19, 38),     // 158
    (19, 28, 38),    // 159
    // 160–169
    (0, 63, 255),    // 160
    (127, 159, 255), // 161
    (0, 41, 165),    // 162
    (82, 103, 165),  // 163
    (0, 31, 127),    // 164
    (63, 79, 127),   // 165
    (0, 19, 76),     // 166
    (38, 47, 76),    // 167
    (0, 9, 38),      // 168
    (19, 23, 38),    // 169
    // 170–179
    (0, 0, 255),     // 170
    (127, 127, 255), // 171
    (0, 0, 165),     // 172
    (82, 82, 165),   // 173
    (0, 0, 127),     // 174
    (63, 63, 127),   // 175
    (0, 0, 76),      // 176
    (38, 38, 76),    // 177
    (0, 0, 38),      // 178
    (19, 19, 38),    // 179
    // 180–189
    (63, 0, 255),    // 180
    (159, 127, 255), // 181
    (41, 0, 165),    // 182
    (103, 82, 165),  // 183
    (31, 0, 127),    // 184
    (79, 63, 127),   // 185
    (19, 0, 76),     // 186
    (47, 38, 76),    // 187
    (9, 0, 38),      // 188
    (23, 19, 38),    // 189
    // 190–199
    (127, 0, 255),   // 190
    (191, 127, 255), // 191
    (82, 0, 165),    // 192
    (124, 82, 165),  // 193
    (63, 0, 127),    // 194
    (95, 63, 127),   // 195
    (38, 0, 76),     // 196
    (57, 38, 76),    // 197
    (19, 0, 38),     // 198
    (28, 19, 38),    // 199
    // 200–209
    (191, 0, 255),   // 200
    (223, 127, 255), // 201
    (124, 0, 165),   // 202
    (145, 82, 165),  // 203
    (95, 0, 127),    // 204
    (111, 63, 127),  // 205
    (57, 0, 76),     // 206
    (66, 38, 76),    // 207
    (28, 0, 38),     // 208
    (33, 19, 38),    // 209
    // 210–219
    (255, 0, 255),   // 210
    (255, 127, 255), // 211
    (165, 0, 165),   // 212
    (165, 82, 165),  // 213
    (127, 0, 127),   // 214
    (127, 63, 127),  // 215
    (76, 0, 76),     // 216
    (76, 38, 76),    // 217
    (38, 0, 38),     // 218
    (38, 19, 38),    // 219
    // 220–229
    (255, 0, 191),   // 220
    (255, 127, 223), // 221
    (165, 0, 124),   // 222
    (165, 82, 145),  // 223
    (127, 0, 95),    // 224
    (127, 63, 111),  // 225
    (76, 0, 57),     // 226
    (76, 38, 66),    // 227
    (38, 0, 28),     // 228
    (38, 19, 33),    // 229
    // 230–239
    (255, 0, 127),   // 230
    (255, 127, 191), // 231
    (165, 0, 82),    // 232
    (165, 82, 124),  // 233
    (127, 0, 63),    // 234
    (127, 63, 95),   // 235
    (76, 0, 38),     // 236
    (76, 38, 57),    // 237
    (38, 0, 19),     // 238
    (38, 19, 28),    // 239
    // 240–249
    (255, 0, 63),    // 240
    (255, 127, 159), // 241
    (165, 0, 41),    // 242
    (165, 82, 103),  // 243
    (127, 0, 31),    // 244
    (127, 63, 79),   // 245
    (76, 0, 19),     // 246
    (76, 38, 47),    // 247
    (38, 0, 9),      // 248
    (38, 19, 23),    // 249
    // 250–255: grays
    (51, 51, 51),    // 250
    (91, 91, 91),    // 251
    (132, 132, 132), // 252
    (173, 173, 173), // 253
    (214, 214, 214), // 254
    (255, 255, 255), // 255
];

/// Look up the canonical RGB value for an ACI index (1–255).
///
/// Returns `None` for index 0 (ByBlock) or out-of-range values.
#[inline]
pub fn aci_to_rgb(index: u8) -> Option<(u8, u8, u8)> {
    if index == 0 {
        None
    } else {
        Some(ACI_COLORS[index as usize])
    }
}

/// Find the nearest ACI index (1–255) for an arbitrary RGB color.
///
/// Uses Euclidean distance in RGB space. Ties go to the lower index.
pub fn nearest_aci(r: u8, g: u8, b: u8) -> u8 {
    let mut best_idx: u8 = 7;
    let mut best_dist = u32::MAX;

    for i in 1u16..=255 {
        let (cr, cg, cb) = ACI_COLORS[i as usize];
        let dr = (r as i32) - (cr as i32);
        let dg = (g as i32) - (cg as i32);
        let db = (b as i32) - (cb as i32);
        let dist = (dr * dr + dg * dg + db * db) as u32;
        if dist < best_dist {
            best_dist = dist;
            best_idx = i as u8;
            if dist == 0 {
                break;
            }
        }
    }
    best_idx
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn aci_standard_colors() {
        assert_eq!(aci_to_rgb(1), Some((255, 0, 0))); // Red
        assert_eq!(aci_to_rgb(2), Some((255, 255, 0))); // Yellow
        assert_eq!(aci_to_rgb(3), Some((0, 255, 0))); // Green
        assert_eq!(aci_to_rgb(4), Some((0, 255, 255))); // Cyan
        assert_eq!(aci_to_rgb(5), Some((0, 0, 255))); // Blue
        assert_eq!(aci_to_rgb(6), Some((255, 0, 255))); // Magenta
        assert_eq!(aci_to_rgb(7), Some((255, 255, 255))); // White
    }

    #[test]
    fn aci_byblock_returns_none() {
        assert_eq!(aci_to_rgb(0), None);
    }

    #[test]
    fn nearest_aci_exact_match() {
        assert_eq!(nearest_aci(255, 0, 0), 1); // Red
        assert_eq!(nearest_aci(0, 255, 0), 3); // Green
        assert_eq!(nearest_aci(0, 0, 255), 5); // Blue
        assert_eq!(nearest_aci(255, 255, 0), 2); // Yellow
    }

    #[test]
    fn nearest_aci_approximate() {
        // Near-red should map to red (1) or a red shade
        let idx = nearest_aci(250, 5, 5);
        assert_eq!(idx, 1);
    }

    #[test]
    fn table_length() {
        assert_eq!(ACI_COLORS.len(), 256);
    }

    #[test]
    fn grays_are_correct() {
        assert_eq!(aci_to_rgb(8), Some((128, 128, 128))); // Dark gray
        assert_eq!(aci_to_rgb(9), Some((192, 192, 192))); // Light gray
        assert_eq!(aci_to_rgb(250), Some((51, 51, 51)));
        assert_eq!(aci_to_rgb(255), Some((255, 255, 255)));
    }
}