jelq

use std::fmt::Write as _;

use hmac::{Hmac, Mac};

use sha2::Sha256;

pub struct Secret(Vec<u8>);

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()

}

impl Secret {

    pub fn new(key: Vec<u8>) -> Self {

        Self(key)

    }

    pub fn random() -> Self {

        Self(rand::random::<[u8; 32]>().to_vec())

    }

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

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

        mac.update(message.as_bytes());

        mac

    }

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

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

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

    }

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

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

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

            .verify_slice(&unhex(tag)?)

            .ok()?;

        Some(value)

    }

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

    pub fn mix_seed(&self, seed: u64) -> u64 {

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

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

    }

}