use aoc2021::parsers;
use nom::{character::complete::line_ending, combinator::map, multi::separated_list1, IResult};
use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input = fs::read_to_string("inputs/day_1.txt")?;
    let sonar_scan = parse_sonar_scan(&input).unwrap().1;

    {
        let mut simple_increase_counter = DepthIncreaseCounter::default();
        for (depth, next_depth) in sonar_scan.iter().zip(sonar_scan.iter().skip(1)) {
            if next_depth > depth {
                simple_increase_counter.increment();
            }
        }
        dbg!(simple_increase_counter);
    }

    {
        let windowed_sonar_scan = sonar_scan
            .iter()
            .zip(sonar_scan.iter().skip(1))
            .zip(sonar_scan.iter().skip(2))
            .map(|((depth1, depth2), depth3)| ThreeDepthWindowSum::new([*depth1, *depth2, *depth3]))
            .collect::<Vec<_>>();

        let mut windowed_increase_counter = DepthIncreaseCounter::default();
        for (depth, next_depth) in windowed_sonar_scan
            .iter()
            .zip(windowed_sonar_scan.iter().skip(1))
        {
            if next_depth > depth {
                windowed_increase_counter.increment();
            }
        }
        dbg!(windowed_increase_counter);
    }

    Ok(())
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
struct Depth(u64);

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
struct ThreeDepthWindowSum(u64);

impl ThreeDepthWindowSum {
    fn new(depths: [Depth; 3]) -> ThreeDepthWindowSum {
        ThreeDepthWindowSum(depths.into_iter().map(|d| d.0).sum())
    }
}

fn parse_sonar_scan(input: &str) -> IResult<&str, Vec<Depth>> {
    separated_list1(line_ending, parse_depth)(input)
}

fn parse_depth(input: &str) -> IResult<&str, Depth> {
    map(parsers::u64, |number| Depth(number))(input)
}

#[derive(Default, Debug)]
struct DepthIncreaseCounter(u64);

impl DepthIncreaseCounter {
    fn increment(&mut self) {
        self.0 += 1;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn parses_a_depth() {
        assert_eq!(parse_depth("96\n"), Ok(("\n", Depth(96))));
    }
}