use std::collections::HashMap;

use advent_of_code_2024::{make_main, SResult};

make_main!();

fn solve(lines: Vec<String>) -> SResult<(usize, usize)> {
    assert_eq!(1, lines.len());
    let state: Vec<usize> = lines[0]
        .split_ascii_whitespace()
        .map(|c| c.parse::<usize>().unwrap())
        .collect();

    let mut total = 0;
    for digit in state.iter() {
        total += one(vec!(*digit), 75);
    }

    Ok((one(state, 25), total))
}

fn one(vstate: Vec<usize>, reps: usize) -> usize {
    let mut state: HashMap<usize, usize> = HashMap::default();
    for n in vstate {
        *state.entry(n).or_insert(0) += 1;
    }
    for _ in 0..reps {
        let mut next: HashMap<usize, usize> = HashMap::with_capacity(state.len());
        for (key, count) in state.into_iter() {
            if key == 0 {
                *next.entry(1).or_insert(0) += count;
            } else if digit_count(key) % 2 == 0 {
                let new_digits = split(key);
                *next.entry(new_digits.0).or_insert(0) += count;
                *next.entry(new_digits.1).or_insert(0) += count;
            } else {

                *next.entry(key*2024).or_insert(0) += count;
            }
        }

        state = next;
    }

    state.iter().map(|a| a.1).sum()

}

fn digit_count(mut n: usize) -> usize {
    let mut count = 0;
    while n > 0 {
        count += 1;
        n /= 10;
    }
    count
}

fn split(mut n: usize) -> (usize, usize) {
    let size = digit_count(n);
    let mut a = 0;
    let mut off = 1;
    for _ in 0..size/2 {
        a += (n % 10) * off;
        off *= 10;
        n /= 10;
    }
    (n, a)
}


#[cfg(test)]
mod tests {
    use advent_of_code_2024::input;

    use super::*;
    #[test]
    fn sample_input() {
        let strings: Vec<String> = input!("d11p1.txt");
        let got = solve(strings).unwrap();
        assert_eq!(got, (55312, 65601038650482));
    }
}