/* Created By Angel Uniminin <uniminin@zoho.com> under the terms of MIT */

extern crate colored;
use colored::Colorize;

use std::{env,
          fs::{File},
          io::{Read},
          error::{Error}};

pub struct Config {
    pub pattern: String,
    pub file: String,
}

impl Config {
    pub fn new(mut args: env::Args) -> Result<Config, &'static str> {

        /* Discard the first argument (args[0]), which is the filename along with path. */
        args.next();

        let (file, pattern): (String, String) = (match args.next() {
            Some(arg) => arg,
            None => return Err("Fatal: No file provided!"),
        }, match args.next() {
            Some(arg) => arg.to_lowercase(),
            None => return Err("Fatal: No string pattern provided!"),
        });

        /* var names are same as in the struct, so e dont need explicit key:val initialization style. */
        Ok(Config { file, pattern })
    }

}

/* The lifetime parameters says that: the search results will be valid as long as the contents are valid.
 * Can last even after pattern goes out of scope. */
fn search<'a>(pattern: &str, contents: &'a str) -> Vec<&'a str> {
    let pattern: String = pattern.to_lowercase();

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

fn summarize(occurrence: usize, line_count: u64) -> String {
    let summary: String;

    if occurrence == 0 {
        summary = format!("{:1} {:1} {:1}", "Found".red(), occurrence.to_string().red(), "occurrence!".red())
    } else {
        let (mut occurrence_word, mut line_word): (String, String) = ("occurrence".parse().unwrap(), "line".parse().unwrap());

        match (occurrence, line_count) {
            (0, _) | (1, _) => {
                line_word.push("s".parse().unwrap());
            }
            (_, 0) | (_, 1) => {
                occurrence_word.push("s".parse().unwrap());
            }
            _ => {
                line_word.push("s".parse().unwrap());
                occurrence_word.push("s".parse().unwrap());
            }
        }

        summary = format!("{:1}\n\
						  {:1} {:1} {:1} {:1} {:1} {:1} {:1}{:1}",
                          "--Summary--".yellow(),"*".green().bold(),
                          "Found".green(), occurrence.to_string().trim().blue().bold(),
                          occurrence_word.green(), "in".green(),
                          line_count.to_string().blue().bold(),
                          line_word.green(), "!".green());
    }
    summary
}

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {

    println!("\n{:1} {:1} {:1} {:1} {:1} {:1}\n", "->".bright_blue(),
             "Searching for".green(), &config.pattern.bright_cyan().bold(),
             "in".green(), &config.file.bright_cyan().bold(), "<-".bright_blue());

    /* `?` will return the error(ending fn execution)
     * if it encounters an `Err` in the `Result` it follows. */
    let mut file = File::open(config.file)?;

    let mut contents: String = String::new();
    file.read_to_string(&mut contents)?;

    let results: Vec<&str> = search(&config.pattern, &contents);

    let (mut line_count, mut total_occurrence) = (0u64, 0usize);

    for line in results {
        let occurrences: String = format!("{:1}", line.to_lowercase()
            .matches(&config.pattern).count().to_string().yellow().bold());
        line_count += 1;
        total_occurrence += line.to_lowercase().matches(&config.pattern).count();
        println!("{:1}  [ {:1} ]", line.to_string().magenta(), occurrences);
    } println!();

    println!("{}", summarize(total_occurrence, line_count));

    /* `()` is a unit type. It means that we mostly do not care about return type if it goes well.
     * We do, however, care about the errors that might occur, and that's why the result type
     * exists with a dynamic error return type. */
    Ok(())
}

#[cfg(test)]
mod test {
    /* use every fn from above */
    use super::*;

    #[test]
    fn case_sensitive() {
        let pattern: &str = "is";
        let contents: &str = "\
Hello There!
This is just a random text.
There is no errors.";

        assert_eq!(
            vec!["This is just a random text.",
                 "There is no errors."],
            search(pattern, contents)
        );
    }

    #[test]
    fn case_insensitive() {
        let pattern: &str = "tH";
        let contents: &str = "\
Hello There!
This is another random text.
There should be no errors as well.";

        assert_eq!(
            vec!["Hello There!",
                 "This is another random text.",
                 "There should be no errors as well."],
            search(pattern, contents)
        );
    }

    #[test]
    fn summary_characters_one_occurrence() {
        let data: &str = "\u{1b}[33m--Summary--\u{1b}[0m\n\u{1b}[1;32m*\u{1b}[0m \
		\u{1b}[32mFound\u{1b}[0m \u{1b}[1;34m2\u{1b}[0m \u{1b}[32moccurrences\
		\u{1b}[0m \u{1b}[32min\u{1b}[0m \u{1b}[1;34m1\u{1b}[0m \u{1b}[32mline\
		\u{1b}[0m\u{1b}[32m!\u{1b}[0m";
        assert_eq!(
            data,
            summarize(2, 1)
        );
    }

    #[test]
    fn summary_characters_two_occurrence() {
        let data: &str = "\u{1b}[33m--Summary--\u{1b}[0m\n\u{1b}[1;32m*\u{1b}[0m \
		\u{1b}[32mFound\u{1b}[0m \u{1b}[1;34m9\u{1b}[0m \u{1b}[32moccurrences\
		\u{1b}[0m \u{1b}[32min\u{1b}[0m \u{1b}[1;34m11\u{1b}[0m \u{1b}[32mlines\
		\u{1b}[0m\u{1b}[32m!\u{1b}[0m";
        assert_eq!(
            data,
            summarize(9, 11)
        );
    }
}