pub use self::Error::ParseValueError;
pub use self::Error::ValueTooLargeError;

use base::Base;
use num::pow::checked_pow;
use num::ToPrimitive;

#[derive(Debug)]
#[derive(PartialEq)]
pub struct Literal {
    width: u8,
    value: u64,
}

#[derive(Debug)]
#[derive(PartialEq)]
pub enum Error {
    ParseValueError,
    ValueTooLargeError,
}

impl Literal {
    pub fn new(base: &Base, chars: &str) -> Result<Literal, Error> {
        let radix = match *base {
            Base::Binary => 2u32,
            Base::Octal => 8u32,
            Base::Hexadecimal => 16u32,
        };

        let value = {
            if let Ok(value) = u64::from_str_radix(chars, radix) {
                value
            } else {
                return Err(ParseValueError);
            }
        };

        let width = {
            let digits = chars.len();

            if let Some(max) = checked_pow(radix as u64, digits) {
                let bits = (max as f64).log2().ceil();

                if let Some(result) = bits.to_u8() {
                    result
                } else {
                    return Err(ValueTooLargeError);
                }
            } else {
                return Err(ValueTooLargeError);
            }
        };

        let result = Literal {
            width: width,
            value: value,
        };

        Ok(result)
    }
}

#[cfg(test)]
mod tests {
    use base::Base;
    use literal::Literal;

    #[test]
    fn new_from_base_str() {
        let values = [(Base::Binary, "01001101101", 11, 0x26D),
                      (Base::Octal, "74053740", 24, 0xF057E0),
                      (Base::Hexadecimal, "00BADAB0DE", 40, 0xBADAB0DE)];

        for value in values.iter() {
            let literal = Literal::new(&value.0, value.1).unwrap();

            assert_eq!(literal.width, value.2);
            assert_eq!(literal.value, value.3);
        }
    }
}