//! Rust implementation of hashcash anti-spam / denial of service 
//! counter-measure tool.

extern crate rand;
extern crate chrono;
extern crate base64;
extern crate crypto;
extern crate byteorder;

use base64::{encode, decode};
use crypto::digest::Digest;
use crypto::sha1::Sha1;
use rand::{thread_rng, Rng};
use rand::distributions::{Standard};
use chrono::prelude::*;
use chrono::Duration;
use byteorder::{BigEndian, WriteBytesExt};

const DATE_FMT: &str = "%y%m%d%H%M%S";

/// Stores a destructured hashcash token by its various components.
#[derive(Debug,PartialEq)]
pub struct Token {
    pub ver: u8,
    pub bits: u32,
    pub date: NaiveDateTime,
    pub resource: String,
    pub ext: String,
    pub rand: Vec<u8>,
    pub counter: Vec<u8>,
}

/// Various error types that are used during the validation of a 
/// `hashcash::Token`.
#[derive(Debug)]
pub enum CheckError {
    /// Returned when validating a `hashcash::Token` and the date is older than 
    /// two days.
    ExpiryError,
    /// Returned when validating a `hashcash::Token` and the resulting hash 
    /// does not satisfy the declared difficulty bits.
    DifficultyError,
}

/// Returned when creating a `hashcash::Token` from a `&str` fails due to
/// an invalid input.
#[derive(Debug)]
pub struct ParseError { 
    pub message: &'static str 
}

impl Token {
    /// Given a fully qualified hashcash token string, returns a parsed version 
    /// of the input.
    /// ```
    /// use hashcash::Token;
    ///
    /// let t = "1:4:180606122628:example::OfZIJujxSu6ojd08LI0hLg:AAHz1w";
    /// let token = Token::from_str(t).unwrap();
    ///
    /// println!("{:?}", token);
    /// ```
    pub fn from_str(stamp: &str) -> Result<Token, ParseError> {
        let stamp_string = stamp.to_string();
        let stamp_parts: Vec<&str> = stamp_string.split(":").collect();

        if stamp_parts.len() != 7 {
            return Err(ParseError { 
                message: "Invalid number of parameters" 
            });
        }

        let ver = match stamp_parts[0].parse::<u8>() {
            Ok(n) => n,
            Err(_) => {
                return Err(ParseError {
                    message: "Invalid version specifier" 
                });
            },
        };
        let bits = match stamp_parts[1].parse::<u32>() {
            Ok(n) => n,
            Err(_) => {
                return Err(ParseError {
                    message: "Invalid difficulty specifier"
                });
            },
        };
        let date = match NaiveDateTime::parse_from_str(stamp_parts[2], DATE_FMT) {
            Ok(d) => d,
            Err(_) => {
                return Err(ParseError {
                    message: "Invalid date specifier"
                });
            },
        };
        let rand = match decode(stamp_parts[5]) {
            Ok(v) => v,
            Err(_) => {
                return Err(ParseError {
                    message: "Invalid base64 random string" 
                });
            },
        };
        let counter = match decode(stamp_parts[6]) {
            Ok(v) => v,
            Err(_) => {
                return Err(ParseError {
                    message: "Invalid base64 counter string" 
                });
            },
        };

        Ok(Token { 
            ver, 
            bits, 
            date, 
            resource: stamp_parts[3].to_string(), 
            ext: stamp_parts[4].to_string(), 
            rand, 
            counter,
        })
    }

    /// Given a resource string and a difficulty factor, mints a new 
    /// `hashcash::Token` and returns it.
    /// 
    /// ```
    /// use hashcash::Token;
    ///
    /// let resource = String::from("test@hashcash.rs");
    /// let bits = 4; // very low difficulty - 20 is normal
    /// let token = Token::new(resource, bits);
    /// println!("Token: {}", token.to_string());
    /// ```
    pub fn new(resource: String, bits: u32) -> Token {
        let mut ctr = thread_rng().gen_range(1, 1048576);
        let ext = String::from("");
        let date = get_current_naive_date();
        let ver = 1;

        let rand: Vec<u8> = thread_rng()
            .sample_iter(&Standard)
            .take(16)
            .collect();
        
        loop {
            let mut counter = vec![];
            counter.write_u32::<BigEndian>(ctr).unwrap();

            let stamp = Token {
                ver,
                bits,
                date,
                resource: resource.clone(),
                ext: ext.clone(),
                rand: rand.clone(),
                counter,
            };

            match stamp.check() {
                Ok(_) => {
                    return Token::from_str(&stamp.to_string()).unwrap();
                },
                Err(_) => {
                    ctr += 1;
                },
            }
        }
    }

    /// Validates the `hashcash::Token`, returning any validation errors if 
    /// not valid.
    ///
    /// ```
    /// use hashcash::Token;
    ///
    /// let token = "1:4:180606122628:example::OfZIJujxSu6ojd08LI0hLg:AAHz1w";
    /// 
    /// match Token::from_str(token) {
    ///     Ok(t) => {
    ///         match t.check() {
    ///             Ok(_) => println!("OK"),
    ///             Err(e) => eprintln!("{:?}", e),
    ///         }
    ///     },
    ///     Err(e) => eprintln!("{}", e.message)
    /// }
    /// ```
    pub fn check(&self) -> Result<&Self, CheckError> {
        let mut leading_zeros = 0;
        let mut hasher = Sha1::new();
        let result: &mut [u8] = &mut [0; 20];

        hasher.input_str(&self.to_string());
        hasher.result(result);

        for byte in result {
            let front_zeros = byte.leading_zeros();
            leading_zeros += front_zeros;

            if front_zeros < 8 {
                break;
            }
        }
        
        if leading_zeros < self.bits {
            return Err(CheckError::DifficultyError);
        }

        let expires_after = Duration::days(2);
        let time_delta = get_current_naive_date() - self.date;
        
        if time_delta >= expires_after {
            return Err(CheckError::ExpiryError);
        }

        Ok(self)
    }

    /// Returns a fully qualified hashcash token string suitable for use as a 
    /// `X-Hashcash` header value or otherwise.
    pub fn to_string(&self) -> String {
        let mut rand = encode(&self.rand);
        let mut counter = encode(&self.counter);

        // Pop the base64 == off the rand and counter for "prettier" output
        rand.pop();
        rand.pop();
        counter.pop();
        counter.pop();

        format!(
            "{}:{}:{}:{}:{}:{}:{}",
            self.ver.to_string(),
            self.bits.to_string(),
            self.date.format(DATE_FMT),
            self.resource,
            self.ext,
            rand,
            counter
        )
    }
}

fn get_current_naive_date() -> NaiveDateTime {
    let date_local = Local::now().to_rfc3339();
    let date_normalized = DateTime::parse_from_rfc3339(&date_local).unwrap();
    
    date_normalized.naive_local()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_mints_a_new_valid_stamp() {
        let stamp1 = Token::new(String::from("test@hashcash.rs"), 4);
        stamp1.check().unwrap();
        println!("{}", stamp1.to_string());
        let stamp2 = Token::from_str(&stamp1.to_string()).unwrap();
        stamp2.check().unwrap();
        assert_eq!(stamp1, stamp2);
    }
}