jelq

use std::{fmt::Write as _, sync::LazyLock};

use hmac::{Hmac, Mac};

use sha2::Sha256;

static SECRET: LazyLock<Vec<u8>> = LazyLock::new(|| {

    std::env::var("JELQD_SECRET")

        .map(String::into_bytes)

        .unwrap_or_else(|_| rand::random::<[u8; 32]>().to_vec())

});

fn mac(message: &str) -> Hmac<Sha256> {

    let mut mac = Hmac::<Sha256>::new_from_slice(&SECRET).expect("hmac accepts any key length");

    mac.update(message.as_bytes());

    mac

}

fn hex(bytes: &[u8]) -> String {

    bytes.iter().fold(String::new(), |mut out, b| {

        let _ = write!(out, "{b:02x}");

        out

    })

}

fn unhex(text: &str) -> Option<Vec<u8>> {

    if !text.len().is_multiple_of(2) {

        return None;

    }

    (0..text.len())

        .step_by(2)

        .map(|i| u8::from_str_radix(text.get(i..i + 2)?, 16).ok())

        .collect()

}

pub fn sign(name: &str, value: &str) -> String {

    let tag = mac(&format!("{name}={value}")).finalize().into_bytes();

    format!("{value}.{}", hex(&tag))

}

pub fn verify<'a>(name: &str, signed: &'a str) -> Option<&'a str> {

    let (value, tag) = signed.rsplit_once('.')?;

    mac(&format!("{name}={value}"))

        .verify_slice(&unhex(tag)?)

        .ok()?;

    Some(value)

}

/// Mixes the server secret into a seed, so a public seed and public source cannot predict rolls offline.

pub fn mix_seed(seed: u64) -> u64 {

    let tag = mac(&format!("seed={seed}")).finalize().into_bytes();

    u64::from_le_bytes(tag[..8].try_into().expect("sha256 is longer than 8 bytes"))

}