extern crate crypto;
extern crate clock_ticks;

use crypto::digest::Digest;
use crypto::sha2::Sha256;
use crypto::hmac::Hmac;
use crypto::mac::{Mac,MacResult};

use clock_ticks::precise_time_ns;

#[derive(Debug)]
pub struct Client {
    tid: u64, //long term (tombstone) client id, never changes
    et: u64, // epoch time of initial connection
    utc: f64, //utc time
    key: u64, //shared key
}

impl Client {
    pub fn blank() -> Client {
        Client {
            tid: 0,
            et: 0,
            utc: 0.,
            key: 0,
        }
    }
}

pub struct Msg {
    mid: MacResult, //short term, message id, always changes
    dt: u64, // delta time since initial connection

    data: Vec<u8>,
}

impl Msg {
    pub fn new (client: &Client, data: &[u8]) -> Msg {
        let dt = precise_time_ns() - client.et;
        let key =  b"Jefe".to_vec();
        /*((dt +
                   client.tid +
                   client.key +
                   client.utc as u64) as f64).bytes();*/
        let mut hmac = Hmac::new(Sha256::new(),&key[..]);
        //let mut result: &mut [u8];// = &mut [256];
       // hmac.raw_result(result);
        Msg {
            dt: dt,
            data: data.to_vec(),
            mid: MacResult::new(hmac.result().code()),
        }
    }

    pub fn auth (client: &Client, msg: &Msg) -> bool {
        let key =  b"Jefe".to_vec();
        let mut hmac = Hmac::new(Sha256::new(),&key[..]);
        //let mut result: &mut [u8] = &mut [256];
        //hmac.raw_result(result);

        msg.mid == MacResult::new(hmac.result().code())
    }
}