use std::env;
use std::error::Error;
use std::fs;

/// Estructura de configuración que se utiliza
/// como parámetro para la función search
pub struct Config {
    /// Guardara el patron que se necesita buscar
    pub query: String,

    /// Guardara el nombre del archivo a escanear
    pub filename: String,

    /// Servirá para hacer una búsqueda que distinga
    /// entre mayúsculas en caso de ser false, por el caso
    /// contrario solo devolverá cadenas que coincidan en
    /// capitalización
    pub case_sensitive: bool,
}

/// Implementación de la configuración que contiene
/// Métodos esenciales para el funcionamiento del programa.
impl Config {
    /// Función constructora encargada de inicializar una instancia
    /// de Config, recibe los en los argumentos el tipo env::Args
    /// que consiste en las opciones que se ingresa junto con el
    /// comando.
    ///
    /// # Errors
    ///
    /// En caso de que no se ingrese ningún argumento al llamar a la
    /// función se retornara el error, "Didn't get a query string"
    /// Si se ingresan todo funciona correctamente se retornara
    /// un OK, con la estructura Config iniciada.
    pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
        args.next();

        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };

        let filename = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };

        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

        Ok(Config {
            query,
            filename,
            case_sensitive,
        })
    }
}

/// Recibe una instancia de Config con los parametros para
/// ejecutar la funcion search y imprimir por pantalla cada
/// coincidencia.
///
/// # Example
///
/// ``` rust
/// use minigrep_fracoxza::Config;
/// use minigrep_fracoxza::run;
///
/// let config = Config {
///     query: String::from("test"),
///     filename: String::from("./test.txt"),
///     case_sensitive: true,
/// };
///
/// let result = match run(config) {
///     Ok(v) => assert_eq!((), v),
///     Err(_) => panic!("An error"),
/// };
///
/// ```
///
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.filename)?;

    let results = if config.case_sensitive {
        search(&config.query, &contents)
    } else {
        search_case_insensitive(&config.query, &contents)
    };

    for line in results {
        println!("{}", line);
    }

    Ok(())
}

/// Esta función buscara un elemento en una lista siendo estricto en
/// cuanto a mayúsculas y minúsculas
///
/// # Examples
///
/// ```
/// let contents = String::from("Probando la función\nEsta linea no se debería ver");
/// let query = String::from("and");
///
/// let results = minigrep_fracoxza::search(&query, &contents);
///
/// assert_eq!(results, vec!["Probando la función"]);
///
/// ```
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    contents
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

/// Esta función buscara un elemento en una lista sin distinguir entre
/// mayúsculas y minúsculas
///
/// # Examples
///
/// ```
/// let contents = String::from("ProbAnDo la función\nEsta linea no se debería ver");
/// let query = String::from("aNdO");
///
/// let results = minigrep_fracoxza::search_case_insensitive(&query, &contents);
///
/// assert_eq!(results, vec!["ProbAnDo la función"]);
///
/// ```
pub fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    let str_query = query.as_str();

    contents
        .lines()
        .filter(|line| line.to_lowercase().contains(str_query))
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn case_sensitive() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duck tape.";
        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }

    #[test]
    fn case_insensitive() {
        let query = "rUsT";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";

        assert_eq!(
            vec!["Rust:", "Trust me."],
            search_case_insensitive(query, contents)
        )
    }
}