pub mod parser {
    use std::collections::HashSet;
    use std::fs::File;
    use std::io::{BufRead, BufReader};
    use std::io::prelude::*;

    use serde::Deserialize;
    use serde::Serialize;

    #[derive(Clone, Deserialize, Serialize)]
    pub struct SomeObject {
        pub value: String
    }


    pub struct NumberParser {
        pub filepath: String
    }

    impl NumberParser {
        pub fn filedump(&self) -> Vec<SomeObject> {
            let mut objs: Vec<SomeObject> = Vec::new();

            if let Ok(lines) = self.read_lines(&self.filepath) {
                for line in lines {
                    if let Ok(phonenumber) = line {
                        let myobj: SomeObject = SomeObject {
                            value: phonenumber
                        };

                        if !myobj.value.is_empty() {
                            objs.push(myobj);
                        }
                    }
                }
            }

            return objs;
        }

        pub fn updatevalues(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
            let mut updated: Vec<SomeObject> = Vec::new();

            let mut i: i32 = 0;

            for a in vals {
                println!("Iter {}", i);

                let mut parsed: String = a.value.clone();
                if a.value.len() < 2 {
                    println!("{} is an invalid number", a.value);
                    continue;
                }

                let pars = self.remove_some_data(&parsed);
                parsed.clear();
                parsed = pars;

                println!("{}", parsed.clone());

                let updated_parsed = self.add_prefix(parsed);

                let myobj: SomeObject = SomeObject {
                    value: updated_parsed.clone()
                };

                updated.push(myobj);
                i = i + 1;
            }


            return updated;
        }

        pub fn removedups(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
            let mut tmp: HashSet<String> = HashSet::new();
            let mut mm: Vec<SomeObject> = Vec::new();
            mm.clone_from(vals);
            mm.retain(|e| tmp.insert(e.value.clone()));

            let mut updated: Vec<SomeObject> = Vec::new();

            for t in tmp {
                let so: SomeObject = SomeObject {
                    value: t.clone()
                };

                updated.push(so);
            }

            return updated
        }
        pub fn print_values(&self, vals: &Vec<SomeObject>) {
            for o in vals {
                println!("Value: {}", o.value);
            }
        }

        pub fn save_file(&self, vals: Vec<SomeObject>) -> std::io::Result<()> {
            let filename: String = String::from("numbers.json");

            let json = serde_json::to_string(&vals).unwrap();
            let mut file = File::create(filename)?;
            file.write_all(json.as_bytes())?;
            Ok(())
        }


        fn read_lines(&self, filename: &str) -> std::io::Result<std::io::Lines<BufReader<File>>> {
            let file = File::open(filename)?;
            Ok(BufReader::new(file).lines())
        }

        fn remove_some_data(&self, unparsed: &String) -> String {
            println!("Unparsed: {}", unparsed);

            let mut parsed: String = String::new();

            for i in 0..unparsed.len() {
                let mychar: char = unparsed.chars().nth(i).unwrap();

                if mychar.is_numeric(){
                    parsed.push(mychar);
                }
            }

            println!("Parsed: {}", parsed);

            return parsed;
        }

        fn add_prefix(&self, raw: String) -> String {
            let mut mychars = raw.chars().clone();
            let first_char: char = mychars.nth(0).clone().unwrap();
            let second_char: char = mychars.nth(1).clone().unwrap();

            let last_char_index = raw.len() - 1;
            println!("Size {} last index {}", raw.len(), last_char_index);

            let mut parsed: String = raw.clone();

            if first_char == '1' {
                parsed.insert(0, '+');
            } else if first_char != '+' {
                if second_char != '1' {
                    parsed.insert(0, '+');
                    parsed.insert(1, '1');
                } else {
                    parsed.insert(0, '+');
                    parsed.insert(1, '1');
                } 
            }

            return parsed
        }
    }
}