pub mod day07 {
    use std::collections::HashMap;
    use std::collections::HashSet;
    use std::fmt::Write;

    pub fn run() {
        let path = "data/input_day7.txt";
        let file_string = std::fs::read_to_string(path).unwrap();
        let mut dependencies: HashMap<u8, HashSet<u8>> = HashMap::new();

        for line in file_string.lines() {
            let chars = line.as_bytes();
            let depends_on = chars[5] - 'A' as u8;
            let step = chars[36] - 'A' as u8;

            dependencies
                .entry(step)
                .or_insert(HashSet::new())
                .insert(depends_on);

            dependencies.entry(depends_on).or_insert(HashSet::new());
        }

        let mut num_completed = 0;
        let mut completed: Vec<bool> = vec![false; dependencies.len()];
        let mut completeable: Vec<u8> = Vec::new();
        let mut order: Vec<u8> = Vec::new();

        while num_completed < dependencies.len() {
            for (step, deps) in &dependencies {
                if completed[*step as usize] {
                    continue;
                }

                let mut all_completed = true;
                for dep in deps {
                    if !completed[*dep as usize] {
                        all_completed = false;
                        break;
                    }
                }

                if all_completed {
                    completeable.push(*step);
                }
            }

            completeable.sort();
            order.push(completeable[0]);
            completed[completeable[0] as usize] = true;
            num_completed += 1;

            completeable.clear();
        }

        let mut result: String = String::with_capacity(order.len());
        for step in order {
            result.push(('A' as u8 + step) as char);
        }

        println!("Day 7, Problem 1 - [{}]", result);

        // Problem 2
        let mut num_completed = 0;
        let mut completed: Vec<bool> = vec![false; dependencies.len()];
        let mut in_progress: HashSet<u8> = HashSet::new();
        let mut workable: Vec<u8> = Vec::new();

        #[derive(Copy, Clone)]
        struct Worker {
            step: u8,
            time_left: u8,
        };

        const NO_STEP: u8 = 255;
        const NUM_WORKERS: usize = 5;
        const BASE_TIME: u8 = 60;

        let mut workers: [Worker; NUM_WORKERS] = [Worker {
            step: NO_STEP,
            time_left: 0,
        }; NUM_WORKERS];
        let mut free_workers = NUM_WORKERS;
        let mut time = 0;

        while num_completed < dependencies.len() {
            let mut work_str = String::new();
            write!(&mut work_str, "{}", time).unwrap();

            // Advance time
            let mut did_work = false;
            for worker in &mut workers {
                if worker.step != NO_STEP {
                    write!(&mut work_str, " {}", (worker.step + 'A' as u8) as char).unwrap();

                    worker.time_left -= 1;
                    did_work = true;
                    if worker.time_left == 0 {
                        completed[worker.step as usize] = true;
                        num_completed += 1;
                        in_progress.remove(&worker.step);

                        worker.step = NO_STEP;
                        free_workers += 1;
                    }
                } else {
                    write!(&mut work_str, " .").unwrap();
                }
            }

            if did_work {
                time += 1;
            }

            // All workers busy, advance time!
            if free_workers == 0 {
                continue;
            }

            // Look for steps that are workable but not in_progress
            for (step, deps) in &dependencies {
                if completed[*step as usize] {
                    continue;
                }

                if in_progress.contains(step) {
                    continue;
                }

                let mut all_completed = true;
                for dep in deps {
                    if !completed[*dep as usize] {
                        all_completed = false;
                        break;
                    }
                }

                if all_completed {
                    workable.push(*step);
                }
            }

            // Assign workable steps to workers
            workable.sort();
            let mut i = 0;
            while free_workers > 0 && i < workable.len() {
                for worker in &mut workers {
                    if worker.step == NO_STEP {
                        worker.step = workable[i];
                        worker.time_left = BASE_TIME + worker.step + 1;
                        i += 1;
                        in_progress.insert(worker.step);
                        free_workers -= 1;
                    }

                    if i >= workable.len() {
                        break;
                    }
                }
            }
            workable.clear();
        }

        println!("Day 7, Problem 2 - [{}]", time);
    }
}