use std::collections::HashMap;


pub struct SimpleArgs {
    args: Vec<String>,
}


impl SimpleArgs {
    pub fn new(args: Vec<String>) -> SimpleArgs {
        return SimpleArgs { args: args };
    }

    pub fn parse(&self) -> (Vec<String>, Vec<String>, HashMap<String, String>) {
        let mut normal = vec![];
        let mut flags = vec![];
        let mut vals = HashMap::new();

        let mut skip_next = false;

        for i in 0..self.args.len() {
            let arg = &self.args[i];

            if skip_next {
                skip_next = false;
                continue;
            }

            if arg.starts_with("--") {
                skip_next = true;
                if self.args.len() > i + 1 {
                  vals.insert(arg[2..].to_string(), self.args[i + 1].to_string());
                }
                continue;
            }

            if arg.starts_with('/') || arg.starts_with('-') {
                let flag = arg[1..].to_string();  
              
                if !flags.contains(&flag) {
                  flags.push(flag);
                }
                continue;
            }

            normal.push(arg.to_string());
        }

        return (normal, flags, vals);
    }
}