use std::simd::{
    cmp::{SimdPartialEq, SimdPartialOrd},
    simd_swizzle, u8x16 as V,
};

macro_rules! A {
    [$a: ident; $($b: expr),+] => {
        const $a: V = V::from_array(*concat_bytes!($($b),+));
    };
}

#[must_use]
pub fn dateparse(s: &str) -> Option<(usize, usize, usize)> {
    // inf and sup for indiv. values
    A![LO; b"00/00/00", [0; 8]];
    A![HI; b"19/39/99", [0xFF; 8]];
    A![INTMSK; [b'0'; 16]];
    A![SLHMSK; [b'/'; 16]];
    // as_flattened wont work with concat_bytes!()
    //           m  m  /     d  d  /     y  y
    A![NUMMSK; [10, 1, 0], [10, 1, 0], [10, 1], [0; 8]];
    let b = s.as_bytes();
    let v = V::load_or_default(b);
    let mut valid = true;
    // index 16 for swizzles with INTMSK is b'0'
    // index 15 is \0
    // this will compile to a shuffle, but a relaxed_laneselect would be cool
    const Z: usize = 16;
    const N: usize = 15;
    macro_rules! X { [$($b: expr),+] => {
        simd_swizzle!(v, INTMSK, [$($b),+, N, N, N, N, N, N, N, N])
        //                                 we need better syntax for this
    }; }
    // normalize values by filling blanks, find through indexes of slashes
    let mut v = match (b.len(), v.simd_eq(SLHMSK).to_bitmask()) {
        //    yy/d/m  ->   '0' m  / '0' d  /  y  y
        (6, 0b001010) => X![Z, 0, 1, Z, 2, 3, 4, 5],
        //   yy/dd/m  ->   '0' m  /  d  d  /  y  y
        (7, 0b010010) => X![Z, 0, 1, 2, 3, 4, 5, 6],
        //   yy/d/mm  ->    m  m  / '0' d  /  y  y
        (7, 0b010100) => X![0, 1, 2, Z, 3, 4, 5, 6],
        //  yy/dd/mm
        (8, 0b100100) => v,
        _ => {
            valid = false;
            v
        },
    };

    // est-ce numerique?
    valid &= (v.simd_ge(LO) & v.simd_le(HI)).all();

    // parse
    //   '0' '3' '/' '3' '1' '/' '2' '6'
    // - '0' '0' '0' '0' '0' '0' '0' '0'
    // ---------------------------------
    //    0   3   .   3   1   .   2   6
    // * 10   1   0  10   1   0  10   1
    // ---------------------------------
    //    0   3   0  30   1   0  20   6
    // +  3   0  30   1   0  20   6<<<<
    // ---------------------------------
    //    3   .   .  31   .   .  26
    v -= INTMSK;
    v *= NUMMSK;
    v += v.rotate_elements_left::<1>();

    let n = v.to_array();
    let (m, d, y) = (n[0], n[3], n[6]);

    (valid & (1..=12).contains(&m) & (1..=31).contains(&d))
        .then(|| (m.into(), d.into(), y.into()))
}