//! # uQuery
//!
//! A simple way to create beautiful command line experiences.
//! uQuery allows you both to query the user for data, and display user errors and warnings
//!
//! ## Example
//! ```
//! fn main() {
//! 	uquery::notice("Cli registration form", 1);
//! 	// Asks the user for there favourite food
//! 	let favourite_food = uquery::string("What us your favourite food");
//!
//! 	// Asks the user for their favourite number
//! 	let favourite_number = uquery::integer("What is your favourite number");
//!
//! 	// Asks the user for their name, defaulting to John Doe
//! 	let name = uquery::string_with_default("What is your name", "John Doe");
//!
//!		// Asks the user for comfirmation
//! 	match uquery::boolean("Are you sure you have entered the correct details") {
//!			true => {
//!				// Tells the user that we are creating a user
//!				uquery::notice("Creating  User", 3);
//!
//!				// Prints a mesage about them
//!				println!(
//!					"Welcome {}, You will be prepared {} {}s ",
//!					name,
//!					favourite_food,
//!					favourite_number
//!				);
//!			}
//!			false => {
//!				// Warns the user of not completing the form
//!				uquery::warning(
//!					"You have quit the form, you will now not be registered",
//!					"Redo the form"
//!				);
//!			}
//! 	}
//! }
//! ```

#![warn(missing_docs)]
use colored::*;
use std::io::Write;

/// Queries the user input.
///
/// This does not trim the output but the last newline is removed
pub fn query_untrimmed(string: String) -> String {
    // Prints the String
    print!("{} ", string.to_string().trim());
    std::io::stdout().flush().expect("Error Flushing Stdout");

    // Creates a String to store the users input
    let mut input = String::new();

    // Reads from the standard input.
    std::io::stdin().read_line(&mut input).expect("I/O Error");
    // Returns the user's input.
    input[0..(input.len() - 1)].to_string()
}

/// Same as query_untrimmed, but this time the result removes leading and trailing spaces
pub fn query(string: String) -> String {
    query_untrimmed(string).trim().to_string()
}

/// Queries the user for string input.
pub fn string(string: &str) -> String {
    string_with_default(string, None)
}

/// Queries the user for string input with a default.
///
///  The user can unset the value by typing a space,
/// otherwise, if no string is specified and a deafult is given the default will be used.
pub fn string_with_default(string: &str, def: Option<String>) -> String {
	string_with_default_reference(string, def.as_ref())
}

/// Queries the user for string input with a default.
///
///  The user can unset the value by typing a space,
/// otherwise, if no string is specified and a deafult is given the default will be used.
pub fn string_with_default_reference(string: &str, def: Option<&String>) -> String {
    let string = query_untrimmed(format!(
        "{}{} {}:",
        "::".yellow(),
        {
            match def {
                Some(ref def) => {
                    if def.is_empty() {
                        "".to_string()
                    } else {
                        format!(" (Defaulting to {})", def.green())
                    }
                }
                None => "".to_string(),
            }
        },
        string.normal()
    ));
    if string.is_empty() && def != None {
        return def.unwrap().to_string();
    }
    // This ensures that we can unset the value with a space
    string.trim().to_string()
}

/// Queries the user for integer input.
///
/// This requires the user gives a valid integer or it will ask again.
pub fn int(string: &str) -> i64 {
    int_with_default(string, None)
}

/// Queries the user for integer input.
///
/// This time a default is given which cannot be unset unless another value is given
pub fn int_with_default(string: &str, int: Option<i64>) -> i64 {
    loop {
        let string = query_untrimmed(format!(
            "{}{} {}:",
            "::".cyan(),
            {
                match int {
                    None => "".to_string(),
                    Some(int) => {
                        format!(" (Defaulting to {})", int.to_string().green())
                    }
                }
            },
            string.normal()
        ));
        if int != None && string.is_empty() {
            return int.unwrap();
        }
        match string.parse::<i64>() {
            Ok(n) => return n,
            Err(_e) => println!("Please Enter a Valid Number"),
        }
    }
}

/// Queries the user for boolean input.
///
/// If no response is given a true is implied.
/// If this is not the desired behavour than one can use boolean_with_default.
pub fn bool(string: &str) -> bool {
    boolean_with_default(string, Some(true))
}

/// Queries the user for boolean input.
///
/// If no default is given the user will only be allowed past if the value given begins with a 'y' or a 'n'.
/// Otherwise, they can specify either true or false as the default.
pub fn boolean_with_default(string: &str, def: Option<bool>) -> bool {
    loop {
        let string = query(format!(
            "{} {} {} {} ",
            "::".magenta(),
            string.normal(),
            {
                match def {
                    Some(def) => match def {
                        true => "[Y/n]".green(),
                        false => "[y/N]".green(),
                    },
                    None => "(y/n)".green(),
                }
            },
            "".normal()
        ));
        let first_char_op = string.get(0..1);
        match first_char_op {
            // Checks if we have a response
            Some(first_char_op) => {
                // Checks if we get a yes.
                if first_char_op == "Y" || first_char_op == "y" {
                    return true;
                }
                // Checks if we get a no.
                if first_char_op == "N" || first_char_op == "n" {
                    return false;
                }
                println!("Please Enter a Valid Boolean.")
            }
            // Never Actually Happens
            None => return true,
        }
    }
}

/// Notifies the user through a title.
///
///  The level can be one of four values:
///
/// 1. Full title
/// 2. Sub title
/// 3. Notice
/// 4. Small Notice
///
/// The string should be relatively short, if it is too long then the titles may wrap around multiple lines
/// and look buggy.
pub fn notice(string: &str, level: u8) {
    println!();
    match level {
        1 => {
            if let Some((w, _)) = term_size::dimensions() {
                println!(
                    "{}{}",
                    " ".repeat((w / 2) - (string.len() / 2) - 2),
                    "-".repeat(string.len() + 4)
                );
                println!(
                    "{}| {} |{}",
                    "=".repeat((w / 2) - (string.len() / 2) - 2).green(),
                    string.bold(),
                    "=".repeat((w / 2) - (string.len() / 2) - 2).green()
                );
                println!(
                    "{}{}",
                    " ".repeat((w / 2) - (string.len() / 2) - 2),
                    "-".repeat(string.len() + 4)
                );
            } else {
                println!(
                    "{}| {} |{}",
                    "=====".green(),
                    string.bold(),
                    "=====".green()
                )
            }
        }
        2 => {
            if let Some((w, _)) = term_size::dimensions() {
                println!(
                    "{}{}{}{}{}",
                    " ".repeat(w / 4),
                    "-".repeat((w / 4) - std::cmp::min(string.len() / 2, w / 4))
                        .green(),
                    string,
                    "-".repeat((w / 4) - std::cmp::min(string.len() / 2, w / 4))
                        .green(),
                    " ".repeat(w / 4),
                );
            } else {
                println!("{}| {} |{}", "  -----".green(), string, "-----  ".green())
            }
        }
        3 => {
            if let Some((w, _)) = term_size::dimensions() {
                println!(
                    "{} {} {}",
                    "----".green(),
                    string,
                    "-".repeat((w / 4) - std::cmp::min(string.len() / 2, w / 4))
                        .green(),
                );
            } else {
                println!("{} {} {}", "---".green(), string, "-----  ".green())
            }
        }
        4 => {
            println!("{}", string.green());
        }
        _ => {}
    }
    println!();
}

/// Displays an error to the user.
///
///  This **is not** designed for program-side error,
/// as it prints in colour to the standard output, not the stderr. It also lets you give
/// suggestions, so the user can know what they have done wrong.
pub fn error(string: &str, suggestion: Option<&str>) {
    match suggestion {
        Some(suggestion) => {
            println!(" {} {} {}", "|".cyan(), "Error:".red(), string);
            println!(" {} {} {}", "|".cyan(), "Suggestion:".cyan(), suggestion);
        }
        None => {
            println!("{} {}", "Error:".red(), string);
        }
    }
}

/// Displays a warning to the user.
///
/// This **is not** designed for program-side error,
/// as it prints in colour to the standard output, not the stderr. It also lets you give
/// suggestions, so the user can know what they have done wrong.
pub fn warning(string: &str, suggestion: Option<&str>) {
    match suggestion {
        Some(suggestion) => {
            println!(" | {} {}", "Error:".yellow(), string);
            println!(" | {} {}", "Suggestion:".cyan(), suggestion);
        }
        None => {
            println!("{} {}", "Error:".yellow(), string);
        }
    }
}