fn flash(input: &mut [Vec<u8>], flashed: &mut Vec<(usize, usize)>, i: i32, j: i32) {
    if input[i as usize][j as usize] < 10 {
        return;
    }

    // This one is flashing and hasn't been counted yet...
    if !flashed.contains(&(i as usize, j as usize)) {
        flashed.push((i as usize, j as usize));
        let neighbors = [
            (i - 1, j - 1), (i - 1, j), (i - 1, j + 1),
            (i, j - 1), (i, j + 1),
            (i + 1, j - 1), (i + 1, j), (i + 1, j + 1),
        ];
        for &(c, r) in &neighbors {
            if c < 0 || r < 0 {
                continue;
            }
            if input.get(c as usize).and_then(|row| row.get(r as usize)).is_none() {
                continue;
            }
            input[c as usize][r as usize] += 1;
            flash(input, flashed, c, r);
        }
    }
}

fn step(input: &mut [Vec<u8>]) -> usize {
    let mut flashed: Vec<(usize, usize)> = Vec::new();
    // Step : each level of octopuses increase by one...
    input.iter_mut().flatten().for_each(|e| *e += 1);
    // Step: octopuses flash
    for i in 0..10 {
        for j in 0..10 {
            flash(input, &mut flashed, i, j);
        }
    }
    // Step: octopuses reset to 0...
    input.iter_mut().flatten().for_each(|e| if *e > 9 { *e = 0 });

    flashed.len()
}

fn aoc_11_part1(input: &mut Vec<Vec<u8>>) -> usize {
    let mut c = input.clone();
    (0..100).map(|_| step(&mut c)).sum::<usize>()
}

fn aoc_11_part2(input: &mut Vec<Vec<u8>>) -> usize {
    let mut c = input.clone();
    (0..1000).find(|_| step(&mut c) == 100).unwrap_or(0) + 1
}

fn main() {
    let mut s: Vec<Vec<u8>> = include_str!("../input.txt").lines().into_iter()
        .map(|line| line.chars().filter_map(|c| c.to_string().parse::<u8>().ok()).collect::<Vec<u8>>())
        .collect();

    let result = aoc_11_part1(&mut s);
    println!("Result 1 is: {}", result);

    let result = aoc_11_part2(&mut s);
    println!("Result 2 is: {}", result);
}