day7

use std::borrow::{Borrow, BorrowMut};
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::ops::Deref;

#[derive(Clone, Debug)]
pub struct directory{
    name: &'static str,
    directories: HashMap<&'static str, directory>,
    files: Vec<file>,
    path: Vec<&'static str>
}

#[derive(Clone, Debug)]
pub struct file{
    name: &'static str,
    size: usize
}


fn getSizeMap() -> HashMap<String, usize>
{
    let mut root: directory = directory{ name: "/", directories: Default::default(), files: vec![], path: vec![] };
    let mut current = &mut root;
    let (_, input) = include_str!("../../input7").split_at(6);

    for l in input.split("\n$ ").skip(1)
    {
        if l.starts_with("ls") {
            if current.files.is_empty()
            {
                for item in l.lines().skip(1)
                {
                    if item.starts_with("dir ") {
                        // we dont care about directories until we cd into them
                    } else {
                        let (sizeStr, fileName) = item.split_once(" ").unwrap();
                        current.files.push(file{ name: fileName, size: sizeStr.parse().unwrap() } );
                    }
                }
            }
        }
        else if l.starts_with("cd ..") {
            let path = current.path.clone();
            let mut newCurrent = &mut root;
            for dir in path.iter().skip(1) {
                newCurrent = newCurrent.directories.get_mut(dir).unwrap();
            }
            current = newCurrent;
        }
        else if l.starts_with("cd ") {
            let (_, dirName) = l.trim().split_at(3);

            current = if current.directories.contains_key(dirName) {
                current.directories.get_mut(dirName).unwrap()
            }
                else {
                    let mut newPath = current.path.clone();
                    newPath.push(current.name);
                    current.directories.insert(dirName, directory {
                        name: dirName,
                        directories: Default::default(),
                        files: vec![],
                        path: newPath
                    });
                    current.directories.get_mut(dirName).unwrap()
                }

        }
    }
    //Find sizes
    let mut sizeMap: HashMap<String, usize> = Default::default();
    struct GetSize<'s> { f: &'s dyn Fn(&GetSize, directory, String, &mut HashMap<String, usize>) -> usize }
    let getSize = GetSize {
        f:& |getSize:&GetSize, dir: directory, fullName: String, map:&mut HashMap<String, usize>| {
            if map.contains_key(&*fullName) {
                map.get(&*fullName).unwrap().to_owned()
            }
            else {
                let mut currSize = dir.files.iter().map(|x| x.size).sum::<usize>();
                for directory in dir.directories {
                    currSize += (getSize.f)(getSize, directory.1, (fullName.to_owned() + "/" + directory.0), map);
                }
                map.insert(fullName, currSize);
                currSize
            }
        }
    };

    (getSize.f)(&getSize, root, "".to_string(), &mut sizeMap);
    sizeMap
}


pub fn day7_1(){
    let sizeMap = getSizeMap();
    let mut total = 0;
    for (_, size) in sizeMap {
        if size <= 100000
        {
            total += size;
        }
    }
    println!("ANS: {}",  total);
}

pub fn day7_2(){
    let sizeMap = getSizeMap();
    let freeSize = 70000000 - sizeMap[""];
    let neededFreed = 30000000 - freeSize;
    let mut smallest = usize::MAX;
    for (_, size) in sizeMap {
        if size >= neededFreed && size < smallest
        {
            smallest = size;
        }
    }
    println!("ANS: {}",  smallest);
}