use std::ops::Range;

use anyhow::Result;

use crate::{Problem, Solution};

pub fn parse_range(section: &str) -> Result<Range<usize>> {
    let (start, end) = section.split_once('-').unwrap();
    let start = start.parse::<usize>()?;
    let end = end.parse::<usize>()?;
    Ok(Range { start, end })
}

fn parse_pair(input: &str) -> Result<(Range<usize>, Range<usize>)> {
    let (section_a, section_b) = input.split_once(',').unwrap();

    Ok((parse_range(section_a)?, parse_range(section_b)?))
}

fn range_is_subset((a, b): &(Range<usize>, Range<usize>)) -> bool {
    (a.start <= b.start && a.end >= b.end) || (b.start <= a.start && b.end >= a.end)
}

fn range_is_union((a, b): &(Range<usize>, Range<usize>)) -> bool {
    (a.start <= b.start && a.end >= b.start) || (b.start <= a.start && b.end >= a.start)
}

pub struct Day4;

impl Problem for Day4 {
    const DAY: u8 = 4;

    const INPUT: &'static str = include_str!("../input/day_4.txt");
}

impl Solution for Day4 {
    type Answer1 = usize;

    type Answer2 = usize;

    fn part_1(input: &str) -> Result<Self::Answer1, anyhow::Error> {
        let ranges: Vec<_> = input.lines().map(parse_pair).collect::<Result<_>>()?;
        Ok(ranges.into_iter().filter(range_is_subset).count())
    }

    fn part_2(input: &str) -> Result<Self::Answer2, anyhow::Error> {
        let ranges: Vec<_> = input.lines().map(parse_pair).collect::<Result<_>>()?;
        Ok(ranges.into_iter().filter(range_is_union).count())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const TEST_INPUT: &str = r#"2-4,6-8
2-3,4-5
5-7,7-9
2-8,3-7
6-6,4-6
2-6,4-8"#;

    #[test]
    fn test_part_1_example() -> Result<()> {
        assert_eq!(2, Day4::part_1(TEST_INPUT)?);
        Ok(())
    }

    #[test]
    fn test_part_2_example() -> Result<()> {
        assert_eq!(4, Day4::part_2(TEST_INPUT)?);
        Ok(())
    }
}