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("--") {
                if arg.contains("=") {
                    let split = arg.split_once('=').unwrap();

                    vals.insert(split.0.to_string(), split.1.to_string());
                } else {
                    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);
    }
}