use std::fs::File;
use std::io::{self, BufRead};
use std::path::Path;
use std::collections::HashMap;

fn main() {
    let file_path = String::from("input");
	let mut selected = Vec::<String>::new();
	let mut folders = HashMap::<String, u32>::new();

    println!("In file {}", file_path);

    if let Ok(lines) = read_lines(file_path) {
        // Consumes the iterator, returns an (Optional) String
        for line in lines {
            if let Ok(ip) = line {
                match &ip[..3] {
                    "dir" => {
                        let dir = String::from(ip.split(" ").nth(1).unwrap());
                        folders.insert(String::from(selected.last().unwrap()) + "/" + &dir, 0);
                    },
                    "$ c" => {
                        let dir = String::from(ip.split(" ").nth(2).unwrap());
                        if dir == ".." {
                            selected.pop();
                        }
                        else {
                            if selected.len() > 0 {
                                selected.push(String::from(selected.last().unwrap()) + "/" + &dir);
                            }
                            else {
                                selected.push(String::from(""));
                            }
                        }
                    },
                    "$ l" => (),
                    _ => {
                        for dir in &selected {
                            let file_size = String::from(ip.split(" ").nth(0).unwrap()).parse::<u32>().unwrap();
                            *folders.entry(String::from(dir)).or_insert(0) += file_size;
                        }
                    },
                }
            }
        }
    }

    //println!("{}", folders[""]);
    let minimum = 30000000 - (70000000 - folders[""]);
    let mut result = 0;
    let mut result2 = 70000000;
    for (dir, size) in folders {
        println!("{} {}", dir, size);
        if size < 100000 {
            result += size;
        }
        if size < result2 && size > minimum {
            result2 = size;
        }
    }
    println!("exercise 1: {} exercise 2: {}", result, result2);
}

fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
where P: AsRef<Path>, {
    let file = File::open(filename)?;
    Ok(io::BufReader::new(file).lines())
}