RIFT Auto-Flood Reflection

/// indicates how many FRs we're computing in AUTO FR
pub const MAX_AUTO_FR_FRS: usize = 3;

/// indicates the cluster has no ID, used in computations to omit effects of cluster ID
pub const NO_CLUSTER_ID: UnsignedFloodReflectionClusterIDType = 0;

/// unique v6 prefix for all nodes starts with this
pub fn auto_fr_v6pref(cid: UnsignedFloodReflectionClusterIDType) -> String {
    format!("FD00:{:04X}:B1", cid)
}

/// how many bytes in a v6pref for different purposes
pub const AUTO_FR_V6PREFLEN: usize = 8 * 5;

/// unique v6 prefix for flood reflector purposes starts like this
pub fn auto_fr_v6frpref(cid: UnsignedFloodReflectionClusterIDType) -> String {
    format!("FD00:{:04X}:B2", cid)
}

/// unique v4 prefix for IRB purposes
pub const AUTO_FR_V4LOOPBACKNET: u8 = 10;
pub const AUTO_FR_V4LOOPBACKMASK : usize = 8;

/// auto FR V4 loopback for FRs
pub fn auto_fr_cidfrpref2frv4loopback(_cid: UnsignedFloodReflectionClusterIDType,
                                    preference: u8) -> Result<IPv4Address, ServiceErrorType> {
    if preference > MAX_AUTO_FR_FRS as _ {
        Err(ServiceErrorType::INTERNALRIFTERROR)
    } else {
        let m = ((AUTO_FR_V4LOOPBACKNET as IPv4Address) << (32 - AUTO_FR_V4LOOPBACKMASK)) | (preference as IPv4Address);
        Ok(m)
    }
}

/// auto FR V6 loopback for FRs
pub fn auto_fr_cidfrpref2frv6loopback(cid: UnsignedFloodReflectionClusterIDType,
                                      preference: u8) -> Result<Ipv6Addr, ServiceErrorType> {
    auto_fr_v6prefixcidsid2loopback(&auto_fr_v6frpref(cid), cid, (1 + preference) as _)
}

pub fn auto_fr_cidsid2isisnet(cid: UnsignedFloodReflectionClusterIDType, sid: UnsignedSystemID) -> Vec<u8> {
    let mut r = vec![0x49]; // magic AFI

    // area ID derived from cluster ID
    r.extend(&cid.to_ne_bytes().iter().fold(0x77u16,
                                            |prev, val| (prev ^ (val.rotate_right(4) as u16))).to_ne_bytes());
    // ISIS ID derived from system ID + cid/sid
    r.extend(auto_fr_cidsid2isissid(cid, sid).into_iter());
    // selector non v-node
    r.push(0);

    r
}

/// ISIS system ID derivation
pub fn auto_fr_cidsid2isissid(
    cid: UnsignedFloodReflectionClusterIDType,
    sid: UnsignedSystemID) -> Vec<u8> {

    let sb = auto_fr_v6hash(cid, sid);

    vec![sb[0],
         sb[1],
         sb[2],
         sb[3],
         sb[4] ^ sb[5].rotate_right(4),
         sb[6] ^ sb[7].rotate_right(4),
    ]
}

/// v4 loopback address derivation for every node in auto-flood-reflection, returns address
pub fn auto_fr_cidsid2v4loopback(cid: UnsignedFloodReflectionClusterIDType, sid: UnsignedSystemID) -> IPv4Address {
    let mut derived = sid.to_ne_bytes().iter()
        .fold(0 as IPv4Address, |p, e| (p << 4) ^ (*e as IPv4Address));
    derived ^= cid as IPv4Address;
    // use the byte we loose for entropy
    derived ^= derived >> (32 - AUTO_FR_V4LOOPBACKMASK);
    // and sanitize for loopback range, we nuke 8 bits out
    derived &= (!U32MASKS[AUTO_FR_V4LOOPBACKMASK]) as IPv4Address;

    let (frpr, frm) = auto_fr_v4frpref(cid);
    let v4m = U32MASKS[frm as usize];

    let mut m = ((AUTO_FR_V4LOOPBACKNET as IPv4Address) << (32 - AUTO_FR_V4LOOPBACKMASK)) | derived;

    // collision with elected FR v4 prefixes, rederive
    if (m & v4m as IPv4Address) == frpr {
        derived ^= IPv4Address::MAX;
        derived &= (!U32MASKS[AUTO_FR_V4LOOPBACKMASK]) as IPv4Address;
        m = ((AUTO_FR_V4LOOPBACKNET as IPv4Address) << (32 - AUTO_FR_V4LOOPBACKMASK)) | derived;
    }

    m as _
}

/// V6 loopback derivation for every node in auto fr
pub fn auto_fr_cidsidv6loopback(cid: UnsignedFloodReflectionClusterIDType,
                                  sid: UnsignedSystemID) -> Result<Ipv6Addr, ServiceErrorType> {
    auto_fr_v6prefixcidsid2loopback(&auto_fr_v6pref(cid), cid, sid)
}

/// Function sorts vector of systemIDs first,
/// Followed by a shuffle taking largest/smallest/2nd largest/2nd smallest.
/// Preference is used to take the according subsets to run this algorithm
/// sequentially.
pub(crate) fn auto_fr_sids2frs(mut v: Vec<(FloodReflectionPreferenceType,
                                           UnsignedSystemID)>)
                                 -> Vec<UnsignedSystemID> {
    v.par_sort_by(|(p1, s1),
                   (p2, s2)|
        match p2.cmp(p1) {
            Ordering::Equal => s2.cmp(s1),
            e @ _ => e
        });

    let mut elected = vec![];

    while elected.len() < MAX_AUTO_FR_FRS && !v.is_empty() {
        let pref = (&v[0]).0;

        let mut splitat = 0;
        while splitat < v.len() && (&v[splitat]).0 == pref {
            splitat += 1;
        }

        let mut so = v.split_off(splitat);
        std::mem::swap(&mut v, &mut so);

        let mut mixed = if so.len() > 2 {
            let mut s = so.split_off(so.len() / 2);
            s.reverse();
            interleave(so.into_iter(), s.into_iter())
                .collect::<Vec<_>>()
        } else {
            so
        };

        elected.extend(mixed.drain(..))
    }

    elected.drain(..).map(|(_, sid)| sid).collect()
}

pub(crate) fn auto_fr_v62octets(a: Ipv6Addr) -> Vec<u8> {
    a.octets().iter().cloned().collect()
}

/// generic bytes derivation used for different purposes
pub fn auto_fr_v6hash(cid: UnsignedFloodReflectionClusterIDType, sid: UnsignedSystemID)
                        -> [u8; 8] {
    let sub = (cid as UnsignedSystemID) ^ sid.rotate_right(8);

    sub.to_ne_bytes()
}

/// local address with encoded cluster ID and system ID for collision free identifiers. Basis
/// for several different prefixes.
pub fn auto_fr_v6prefixcidsid2loopback(v6pref: &str, cid: UnsignedFloodReflectionClusterIDType,
                                       sid: UnsignedSystemID) -> Result<Ipv6Addr, ServiceErrorType> {
    assert!(cid != ILLEGAL_CLUSTER_I_D as _);
    let a = format!("{}00::{}",
                    v6pref,
                    sid.to_ne_bytes()
                        .iter()
                        .chunks(2)
                        .into_iter()
                        .map(|chunk|
                            chunk.fold(0u16, |v, n| (v << 8) | *n as u16))
                        .map(|v| format!("{:04X}", v))
                        .collect::<Vec<_>>()
                        .into_iter()
                        .join(":")
    );

    Ipv6Addr::from_str(&a)
        .map_err(|_| ServiceErrorType::INTERNALRIFTERROR)
}

/// cluster prefixes derived instead of advertising default on the cluster to allow
/// for default route on ToF or leaves
pub fn auto_fr_cid2cluster_prefixes(cid: UnsignedFloodReflectionClusterIDType) -> Result<Vec<IPPrefixType>, ServiceErrorType> {
    vec![
        (auto_fr_cidsidv6loopback(cid, ILLEGAL_SYSTEM_I_D as _), AUTO_FR_V6PREFLEN),
        (auto_fr_cidfrpref2frv6loopback(cid, 0 as _), AUTO_FR_V6PREFLEN),
    ]
        .into_iter()
        .map(|(p, _)|
            match p {
                Ok(_) => Ok(
                    IPPrefixType::Ipv6prefix(
                        IPv6PrefixType {
                            address: auto_fr_v62octets(p?),
                            prefixlen: AUTO_FR_V6PREFLEN as _,
                        })),
                Err(e) => Err(e),
            }
        )
        .collect::<Result<Vec<_>, _>>()
}