use crate::days::Solution;

pub struct Day03;

impl Solution for Day03 {
    type Input = Vec<Vec<u32>>;

    fn parse(&self, data: &str) -> Self::Input {
        data.split("\n")
            .filter(|s| !s.is_empty())
            .map(|s| s.chars().map(|c| c.to_digit(10).unwrap_or(0)).collect())
            .collect()
    }

    fn part1(&self, input: &Self::Input) -> usize {
        input
            .iter()
            .map(|l| {
                let (i1, m1) = max(&l[..l.len() - 1]);
                let (_, m2) = max(&l[i1 + 1..]);
                10 * m1 + m2
            })
            .sum::<u32>() as usize
    }

    fn part2(&self, input: &Self::Input) -> usize {
        println!("Part2");
        input
            .iter()
            .map(|l| {
                (0..12)
                    .rfold((0, 0), |(start_index, joltage), n| {
                        let (i, m) = max(&l[start_index..l.len() - n]);
                        (
                            start_index + i + 1,
                            usize::pow(10, n as u32) * m as usize + joltage,
                        )
                    })
                    .1
            })
            .sum()
    }
}

fn max(l: &[u32]) -> (usize, u32) {
    let x = l.iter().enumerate().fold(
        (0, 0),
        |(index_m, m), (i, &x)| if x > m { (i, x) } else { (index_m, m) },
    );

    println!("Max of {:?} is {:?}", l, x);
    x
}