use std::fs::File;
use std::io::{self, Error, Read, Write};
use std::path::Path;

/// Informs whether a read was successfull or not.
///
/// After a read try, return the content or an error explaining what went wrong.
/// The content is of type `Vec<u8>`.
pub type ReadResult = Result<Vec<u8>, Error>;

/// Informs whether a write was successfull or not.
///
/// A wraper around `io::Error`. The `Ok` value isn't used.
pub type WriteResult = Result<(), Error>;

/// Takes a slice of `u8` (chars) and parses it into a number.
///
/// It uses the same approach as C: if the next character represents a number,
/// then parse it; if not, stop the algorithm.
fn atoi(chars: &[u8]) -> u64 {
    chars.iter()
        .take_while(|&n| 48 <= *n && *n <= 57)
        .fold(0, |acc, &n| (acc * 10) + (n - 48) as u64)
}

/// Convert a vector of bytes into a vector of numbers.
///
/// Splits a vector of `u8` by spaces (the value `32` in ASCII) into many groups
/// of bytes and then convert those groups into numbers.
///
/// # Examples
///
/// ```
/// use kripher::utils::split_into_numbers;
///
/// let chars = vec![49, 49, 32, 52, 50];
/// let result = vec![11, 42];
///
/// assert_eq!(split_into_numbers(chars), result);
/// ```
pub fn split_into_numbers(chars: Vec<u8>) -> Vec<u64> {
    chars.split(|&c| c == 32)
        .filter(|s| !s.is_empty())
        .map(atoi)
        .collect::<Vec<u64>>()
}

/// Reads a `Read` to a vector of `u8`.
///
/// If any error is found, return an `Err`.
fn read<T: Read>(mut reader: T) -> ReadResult {
    let mut res = Vec::new();

    match reader.read_to_end(&mut res) {
        Ok(_) => Ok(res), // Return the vector.
        Err(e) => Err(e), // Build a new error, of type ReadResult.
    }
}

/// Reads from a file or from stdin.
///
/// If `file` is `Some`, then use it as a filename to read from, Otherwise, read
/// from the standard input.
///
/// If any error is found, return an `Err`.
///
/// # Examples
///
/// ```
/// use kripher::utils::read_from;
///
/// // Read from standard input.
/// match read_from::<String>(None) {
///     Ok(_) => println!("Read correctly!"),
///     Err(_) => println!("Oops!"),
/// }
/// ```
pub fn read_from<P>(file: Option<P>) -> ReadResult
    where P: AsRef<Path>
{
    match file {
        Some(file) => File::open(file).and_then(read),
        None => read(io::stdin()),
    }
}

/// Writes a `String` to a `Write`.
fn write<T: Write>(mut write: T, content: String) -> WriteResult {
    write.write_all(content.as_bytes())
}

/// Writes `content` to a file or to stdout.
///
/// If `file` is `Some`, then use it as a filename to write to. Otherwise, write
/// to the standard output.
///
/// If any error is found, return an `Err`.
///
/// # Examples
///
/// ```
/// use kripher::utils::write_to;
///
/// // Write 'Content' to a file.
/// match write_to(Some("/tmp/output"), String::from("Content")) {
///     Ok(_) => println!("write successfull"),
///     Err(_) => println!("Oops!"),
/// }
/// ```
pub fn write_to<P>(file: Option<P>, content: String) -> WriteResult
    where P: AsRef<Path>
{
    match file {
        Some(file) => File::create(file).and_then(|f| write(f, content)),
        None => write(io::stdout(), content),
    }
}

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

    fn chars(numbers: &str) -> Vec<u8> {
        numbers.chars()
            .map(|c| c as u8)
            .collect::<Vec<u8>>()
    }

    #[test]
    fn test_starting_zero() {
        let bytes = chars("01 002 0030");

        assert_eq!(split_into_numbers(bytes), vec![1, 2, 30]);
    }

    #[test]
    fn test_middle_letter() {
        let bytes = chars("435a 33ss56 aa");

        assert_eq!(split_into_numbers(bytes), vec![435, 33, 0]);
    }

    #[test]
    fn test_multiple_spaces() {
        let bytes = chars("45  545     76");

        assert_eq!(split_into_numbers(bytes), vec![45, 545, 76]);
    }
}