wc.rs

use std::collections::HashMap;
use std::env;
use std::fs;
use std::io;

struct Args {
    args: Vec<String>,
    program_args_len: usize,
    has_args: bool,
    last_arg: String,
    last_arg_is_switch: bool,
}

impl Args {
    fn new(args: Vec<String>) -> Self {
        let program_args_len = args.len() - 1;
        let has_args = program_args_len > 0;
        let last_arg = if has_args {
            args.get(args.len() - 1).unwrap()
        } else {
            ""
        }
        .to_string();
        let last_arg_is_switch = regex::Regex::new(r"^--?[a-zA-Z0-9]+$")
            .unwrap()
            .is_match(&last_arg);

        Args {
            args,
            program_args_len,
            has_args,
            last_arg,
            last_arg_is_switch,
        }
    }

    fn reading_file(&self) -> bool {
        self.has_args && !self.last_arg_is_switch
    }

    fn get_flag(&self) -> String {
        if self.program_args_len > 2 {
            self.args[1].clone()
        } else {
            "".to_string()
        }
    }
}

enum Source {
    Stdin,
    File(String),
}

struct Text {
    contents: String,
    size: usize,
    lines: usize,
    words: usize,
    chars: usize,
}

impl Text {
    fn stdin() -> String {
        io::stdin()
            .lines()
            .map(|line| line.unwrap_or_default())
            .collect::<Vec<String>>()
            .join("\n")
    }

    fn fs(path: String) -> String {
        fs::read_to_string(path).unwrap()
    }

    fn new(source: Source) -> Text {
        let contents = match source {
            Source::Stdin => Self::stdin(),
            Source::File(path) => Self::fs(path),
        };

        let size = contents.bytes().len();
        let lines = contents.lines().count();
        let words = contents.split_ascii_whitespace().count();
        let chars = contents.chars().count();

        Text { contents, size, lines, words, chars }
    }
}

pub fn run() {
    let args = Args::new(env::args().collect());

    let flag = args.get_flag();

    let source = if !args.reading_file() {
        Source::Stdin
    } else {
        Source::File(args.last_arg.clone())
    };

    let contents = Text::new(source);

    let mut results: HashMap<String, usize> = HashMap::new();
    results.insert("-c".to_string(), contents.size);
    results.insert("-l".to_string(), contents.lines);
    results.insert("-w".to_string(), contents.words);
    results.insert("-m".to_string(), contents.chars);

    if flag == "" {
        println!("{} {} {} {}", contents.lines, contents.words, contents.size, args.last_arg);
    }

    results.get(&flag);
}