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

///
/// The struct to hold the arg parameter
/// 
/// query: the string to search
/// filename: the file to search
/// 
/// 
pub struct Config{
    pub query: String,
    pub filename: String,
}

impl Config{
    // error handling schema: return Result, the first item contains the value, and the next contains the error
    // the signature can be explained as: return either Ok(Config) or Err(string)

    // env::Args is an iterator type, as we need to iterate through the args, so, we need it to be mutable

    ///
    /// The method to construct a Config struct from command line
    /// 
    pub fn new(mut args: env::Args) -> Result<Config, &'static str>{

        args.next(); // the first arg is always the path of exe

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

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

        /*
        if args.len() < 3{
            return Err("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();
        */

        Ok(Config{query, filename})
    }
}

// Box<dyn Error> means any error type, as long as they implement the Error trait
pub fn run(config: Config) -> Result<(), Box<dyn Error>>{
    let contents = fs::read_to_string(config.filename)?;

    let result = search(&config.query, &contents);
    for line in result{
        println!("{}", line);
    }    
    Ok(())
}

fn search<'a>(query: &'a str, contents: &'a str)-> Vec<&'a str>{
    /* the introduce of temporary vec hurts the future usage of concurrency: the temp vec need to be merged
    let mut result = Vec::new();
    for line in contents.lines(){
        if line.contains(query){
            result.push(line.trim());
        }
    }
    result
    */
    contents
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

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

    #[test]
    fn one_result(){
        let query = "duct";
        let contents = "\
        Rust;
        safe, fast, productive.
        Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(&query, &contents));
    }


}