//! # Introduction
//! Easy Adds is a crate which provides simple rust for beginers and schools
//! Rust is not an easy langage for beginers but with this crate they can do cool things without dificulty
//! 
//! For using this library writte this in the first line of your code
//! ```
//! extern crate easy_adds;
//! use easy_adds::*;
//! ```
//! 
//! # Some usefull functions
//! ```
//! // Generate a random number between 0 and 1
//! random_f64()
//! // NOTE: You can also use random_f32 which return a f32 number instead of a f64 number
//! // You can also generate a number between two numbers with:
//! random(-5,5)
//! // This function returns a i32 between the first and the second number (NOTE: The first number is included but not the second)
//! 
//! // Get an input form the user of the given type ex: input_i64("Type a number: ")
//! input_<Type>("Mesage to sended to the user")
//! // Here all the types supported: f32,f64,bool,i8,i16,i32,i64,u8,u16,u32,u64,string
//! // Note to make a string input: input("Mesage to sended to the user")
//! // You can also use the try_ statement to get an Option<Type> like:
//! try_input_<Type>("Mesage to sended to the user")
//! // This return an option of the given type an this is avaible for all types of the input expect String
//! ```

#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
       html_favicon_url = "https://www.rust-lang.org/favicon.ico")]



extern crate rand;


use std::io::{stdin};
use rand::prelude::*;

#[cfg(test)]
mod tests {
    #[test]
    fn malou() {
    	assert_eq!("test","test");
        //assert_eq!(crate::input_str("somethings: "), "Malou");
        //assert_eq!(crate::try_input_f64("somethings: ").unwrap(), 32.0);
        //assert_eq!(crate::input_bool("somethings: "), true);
        //assert_eq!(crate::random_f32(), 0.0);
    }
}

/// This function generate random `i32` between `i32` `start` and `end`
/// Based on top of `rand` crate
pub fn random(start: i32,end: i32) -> i32 {
	let mut rng: rand::rngs::ThreadRng = rand::thread_rng();
	rng.gen_range(start,end)
}

/// This function generate random `f64` between 0 and 1.
/// Based on top of `rand` crate.
pub fn random_f64() -> f64 {
	let mut rng: rand::rngs::ThreadRng = rand::thread_rng();
	rng.gen()
}

/// This function generate random `f32` between 0 and 1.
/// Based on top of `rand` crate.
pub fn random_f32() -> f32 {
	let mut rng: rand::rngs::ThreadRng = rand::thread_rng();
	rng.gen()
}

/// This function take a `String` input from the user like `input` and `input_string`
pub fn input_str(message: &str) -> String {
    let mut s=String::new();
    print!("{}",message);
    stdin().read_line(&mut s).expect("Did not enter a correct string");
    if let Some('\n')=s.chars().next_back() {
        s.pop();
    }
    if let Some('\r')=s.chars().next_back() {
        s.pop();
    }
    s
}

/// This function take a `String` input from the user like `input_str` and `input_string`
pub fn input(message: &str) -> String {
    input_str(message)
}

/// This function take a `String` input from the user like `input` and `input_str`
pub fn input_string(message: &str) -> String {
    input_str(message)
}

/// This function take a `f64` input from the user and return an `Option`
pub fn try_input_f64(message: &str) -> Option<f64> {
   match input_str(message).parse::<f64>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `f64` input from the user and return an `f64` but panic if bad input
pub fn input_f64(message: &str) -> f64 {
   match input_str(message).parse::<f64>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `f32` input from the user and return an `Option`
pub fn try_input_f32(message: &str) -> Option<f32> {
   match input_str(message).parse::<f32>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `f32` input from the user and return an `f32` but panic if bad input
pub fn input_f32(message: &str) -> f32 {
   match input_str(message).parse::<f32>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `i64` input from the user and return an `Option`
pub fn try_input_i64(message: &str) -> Option<i64> {
   match input_str(message).parse::<i64>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `i64` input from the user and return an `i64` but panic if bad input
pub fn input_i64(message: &str) -> i64 {
   match input_str(message).parse::<i64>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `i32` input from the user and return an `Option`
pub fn try_input_i32(message: &str) -> Option<i32> {
   match input_str(message).parse::<i32>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `i32` input from the user and return an `i32` but panic if bad input
pub fn input_i32(message: &str) -> i32 {
   match input_str(message).parse::<i32>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `i16` input from the user and return an `Option`
pub fn try_input_i16(message: &str) -> Option<i16> {
   match input_str(message).parse::<i16>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `i16` input from the user and return an `i16` but panic if bad input
pub fn input_i16(message: &str) -> i16 {
   match input_str(message).parse::<i16>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `i8` input from the user and return an `Option`
pub fn try_input_i8(message: &str) -> Option<i8> {
   match input_str(message).parse::<i8>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `i8` input from the user and return an `i8` but panic if bad input
pub fn input_i8(message: &str) -> i8 {
   match input_str(message).parse::<i8>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `u64` input from the user and return an `Option`
pub fn try_input_u64(message: &str) -> Option<u64> {
   match input_str(message).parse::<u64>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `u64` input from the user and return an `u64` but panic if bad input
pub fn input_u64(message: &str) -> u64 {
   match input_str(message).parse::<u64>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `u32` input from the user and return an `Option`
pub fn try_input_u32(message: &str) -> Option<u32> {
   match input_str(message).parse::<u32>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `u32` input from the user and return an `u32` but panic if bad input
pub fn input_u32(message: &str) -> u32 {
   match input_str(message).parse::<u32>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `u16` input from the user and return an `Option`
pub fn try_input_u16(message: &str) -> Option<u16> {
   match input_str(message).parse::<u16>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `u16` input from the user and return an `u16` but panic if bad input
pub fn input_u16(message: &str) -> u16 {
   match input_str(message).parse::<u16>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}

/// This function take a `u8` input from the user and return an `Option`
pub fn try_input_u8(message: &str) -> Option<u8> {
   match input_str(message).parse::<u8>() {
   		Ok(e) => {
   			Some(e)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `u8` input from the user and return an `u8` but panic if bad input
pub fn input_u8(message: &str) -> u8 {
   match input_str(message).parse::<u8>() {
   		Ok(e) => {
   			e
   		},
   		_ => {
   			panic!("Can't parse user input");
   		}
   }
}


/// This function take a `bool` input from the user and return an `Option`
pub fn try_input_bool(message: &str) -> Option<bool> {
	let de: &str = &(input_str(message).to_lowercase());
   match de {
   		"true" => {
   			Some(true)
   		},
   		"false" => {
   			Some(false)
   		},
   		"t" => {
   			Some(true)
   		},
   		"f" => {
   			Some(false)
   		},
   		"v" => {
   			Some(true)
   		},
   		"o" => {
   			Some(true)
   		},
   		"faux" => {
   			Some(false)
   		},
   		"oui" => {
   			Some(true)
   		},
   		"si" => {
   			Some(true)
   		},
   		"non" => {
   			Some(false)
   		},
   		"vrai" => {
   			Some(true)
   		},
   		"no" => {
   			Some(false)
   		},
   		"yes" => {
   			Some(true)
   		},
   		"0" => {
   			Some(false)
   		},
   		"1" => {
   			Some(true)
   		},
   		_ => {
   			None
   		}
   }
}

/// This function take a `bool` input from the user and return an `bool` return false if there are an bad input
pub fn input_bool(message: &str) -> bool {
   match try_input_bool(message) {
   		Some(e) => {
   			e
   		},
   		_ => {
   			false
   		}
   }
}
/*
pub fn input_string(message: &str) -> String {

}

pub fn input_f64_catch(message: &str) -> Option<f64> {

}*/