pub mod v4;
mod rng;

pub(crate) type Bytes = [u8; 16];

pub struct Uuid(Bytes);

#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum Variant {
    NCS = 0u8,
    Default = 0x80,
    Microsoft = 0xc0,
    Future = 0xe0,
}

#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum Version {
    Nil = 0,
    Time = 1,
    DCE = 2,
    MD5 = 3,
    Random = 4,
    SHA1 = 5,
    Unknown = u8::MAX
}

impl Uuid {
    pub fn new(version: Version) -> Self {
        match version {
            Version::Nil => Self::new_nil(),
            Version::Random => Self::new_random(),
            _ => panic!("Unsupported UUID version: {:?}", version)
        }
    }

    pub fn new_nil() -> Self {
        Uuid(Uuid::nil_bytes())
    }

    #[inline]
    pub const fn as_bytes(&self) -> &[u8] {
        &self.0
    }

    pub const fn get_variant(&self) -> Variant {
        match self.as_bytes()[8] {
            x if x & 0x80 == 0 => Variant::NCS,
            x if x & 0x40 == 0 => Variant::Default,
            x if x & 0x20 == 0 => Variant::Microsoft,
            _ => Variant::Future
        }
    }

    pub const fn get_version_num(&self) -> u8 {
        self.as_bytes()[6] >> 4
    }

    pub const fn get_version(&self) -> Version {
        match self.get_version_num() {
            0 => Version::Nil,
            1 => Version::Time,
            2 => Version::DCE,
            3 => Version::MD5,
            4 => Version::Random,
            5 => Version::SHA1,
            _ => Version::Unknown
        }
    }

    #[inline]
    const fn nil_bytes() -> Bytes {
        [0u8; 16]
    }

    #[inline]
    fn set_variant(bytes: &mut Bytes, variant: Variant) {
        let variant = variant as u8;
        let byte = bytes[8] & 0xf;

        bytes[8] = variant & byte;
    }

    #[inline]
    fn set_version(bytes: &mut Bytes, version: Version) {
        bytes[6] |= (version as u8) << 4;
    }
}

impl Default for Uuid {
    fn default() -> Self {
        Uuid::new_nil()
    }
}

// impl AsRef<Bytes> for Uuid {
//     fn as_ref(&self) -> &Bytes {
//         &self.0
//     }
// }