//! Time-based one-time passwords (RFC 6238, SHA-1, six digits, 30 s) and
//! recovery codes (hub spec §15.3).

use hmac::{Hmac, Mac};
use sha1::Sha1;

pub fn new_secret() -> String {
    let mut b = [0u8; 20];
    rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut b);
    base32::encode(base32::Alphabet::Rfc4648 { padding: false }, &b)
}

fn code_at(secret: &str, counter: u64) -> Option<String> {
    let key = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, secret)?;
    let mut mac = Hmac::<Sha1>::new_from_slice(&key).ok()?;
    mac.update(&counter.to_be_bytes());
    let digest = mac.finalize().into_bytes();
    let offset = (digest[19] & 0x0f) as usize;
    let bin = ((digest[offset] as u32 & 0x7f) << 24)
        | ((digest[offset + 1] as u32) << 16)
        | ((digest[offset + 2] as u32) << 8)
        | digest[offset + 3] as u32;
    Some(format!("{:06}", bin % 1_000_000))
}

/// The current code, for tests and the enrolment check.
pub fn current(secret: &str, now_s: u64) -> Option<String> {
    code_at(secret, now_s / 30)
}

/// Accept the code for this step and its neighbours (one step of drift).
pub fn verify(secret: &str, code: &str, now_s: u64) -> bool {
    let code = code.trim().replace(' ', "");
    let step = now_s / 30;
    [step.wrapping_sub(1), step, step + 1].iter().any(|c| code_at(secret, *c).is_some_and(|x| x == code))
}

/// `otpauth://` URI for authenticator apps.
pub fn uri(site: &str, username: &str, secret: &str) -> String {
    let label = format!("{site}:{username}").replace(' ', "%20");
    format!("otpauth://totp/{label}?secret={secret}&issuer={}&algorithm=SHA1&digits=6&period=30", site.replace(' ', "%20"))
}

/// The provisioning URI as an SVG QR code.
pub fn qr_svg(uri: &str) -> Option<String> {
    let code = qrcode::QrCode::new(uri.as_bytes()).ok()?;
    Some(code.render::<qrcode::render::svg::Color>().min_dimensions(180, 180).quiet_zone(true).build())
}

/// Ten recovery codes; stored as BLAKE3 hashes separated by commas.
pub fn new_recovery_codes() -> (Vec<String>, String) {
    let codes: Vec<String> = (0..10).map(|_| super::random_hex(5)).collect();
    let stored = codes.iter().map(|c| hex::encode(blake3::hash(c.as_bytes()).as_bytes())).collect::<Vec<_>>().join(",");
    (codes, stored)
}

/// Use a recovery code: the remaining stored codes if it matched.
pub fn use_recovery_code(stored: &str, code: &str) -> Option<String> {
    let hash = hex::encode(blake3::hash(code.trim().as_bytes()).as_bytes());
    let all: Vec<&str> = stored.split(',').filter(|s| !s.is_empty()).collect();
    if !all.contains(&hash.as_str()) {
        return None;
    }
    Some(all.into_iter().filter(|h| *h != hash).collect::<Vec<_>>().join(","))
}

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

    #[test]
    fn rfc_6238_vector() {
        // RFC 6238 appendix B, SHA-1, secret "12345678901234567890", 59 s → 94287082 (8 digits); 6 digits are the last six.
        let secret = base32::encode(base32::Alphabet::Rfc4648 { padding: false }, b"12345678901234567890");
        assert_eq!(current(&secret, 59).unwrap(), "287082");
        assert_eq!(current(&secret, 1111111109).unwrap(), "081804");
        assert!(verify(&secret, "287082", 59));
        assert!(verify(&secret, "287 082", 75), "drift of one step");
        assert!(!verify(&secret, "000000", 59));
    }

    #[test]
    fn recovery_codes() {
        let (codes, stored) = new_recovery_codes();
        assert_eq!(codes.len(), 10);
        let rest = use_recovery_code(&stored, &codes[3]).unwrap();
        assert!(use_recovery_code(&rest, &codes[3]).is_none(), "a code is single use");
        assert!(use_recovery_code(&rest, &codes[4]).is_some());
        assert!(qr_svg(&uri("OxygenHub", "andy", &new_secret())).unwrap().contains("<svg"));
    }
}