use crate::tasks::day05::IntCodeComputer;
use itertools::Itertools;

#[allow(dead_code)]
pub fn run() {
    let prog_code: Vec<_> = std::fs::read_to_string("input/day07.txt")
        .unwrap()
        .split(",")
        .map(|s| s.parse::<i128>().unwrap())
        .collect();
    task1(prog_code.clone());
    task2(prog_code.clone());
}

fn task1(input: Vec<i128>) {
    let phases = vec![0, 1, 2, 3, 4];
    let result = phases
        .iter()
        .permutations(phases.len())
        .map(|perm| {
            perm.iter().fold(0, |signal, phase| {
                let mut computer = IntCodeComputer::new(
                    vec![**phase, signal],
                    input.clone().into_iter().enumerate().collect(),
                );
                computer.run_until_end();
                *computer.get_output().last().unwrap()
            })
        })
        .max();
    println!("Task 1: best signal is {}", result.unwrap());
}

fn task2(input: Vec<i128>) {
    let phases = vec![5, 6, 7, 8, 9];
    let result = phases
        .iter()
        .permutations(phases.len())
        .map(|perm| {
            let mut machines: Vec<IntCodeComputer> = perm
                .iter()
                .map(|phase| {
                    let mut comp = IntCodeComputer::new(
                        vec![**phase],
                        input.clone().into_iter().enumerate().collect(),
                    );
                    comp.run_until_input_empty();
                    comp
                })
                .collect();
            let mut m = 0;
            let mut signal = 0;
            let mut done = false;
            while !done {
                let mach = &mut machines[m];
                mach.set_input(&vec![signal]);
                let machine_done = mach.run_until_input_empty();
                signal = *mach.get_output().last().unwrap();
                mach.clear_output();
                if machine_done && m == 4 {
                    done = true;
                }
                m = (m + 1) % machines.len();
            }
            signal
        })
        .max();
    println!("Task 2: best signal with looping is {}", result.unwrap());
}