use std::ops::RangeInclusive;

use aoc_runner_derive::{aoc, aoc_generator};

struct Database {
    fresh_ingredients: Vec<RangeInclusive<u64>>,
    available_ingredients: Vec<u64>,
}

#[aoc_generator(day5)]
fn parse(input: &str) -> Database {
    let mut fresh_ingredients = Vec::new();
    let mut available_ingredients = Vec::new();
    let mut parsing_ranges = true;
    for line in input.lines() {
        if line == "" {
            parsing_ranges = false;
            continue;
        }
        if parsing_ranges {
            let (start, end) = line.split_once(|c| c == '-').unwrap();
            fresh_ingredients.push(RangeInclusive::new(
                start.parse().unwrap(),
                end.parse().unwrap(),
            ));
        } else {
            available_ingredients.push(line.parse().unwrap())
        }
    }
    Database {
        fresh_ingredients,
        available_ingredients,
    }
}

#[aoc(day5, part1)]
fn part1(input: &Database) -> u64 {
    input
        .available_ingredients
        .iter()
        .filter(|i| input.fresh_ingredients.iter().any(|r| r.contains(i)))
        .count() as u64
}

#[aoc(day5, part2)]
fn part2(input: &Database) -> u64 {
    0
}

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

    const EXAMPLE: &str = "3-5
10-14
16-20
12-18

1
5
8
11
17
32";

    #[test]
    fn part1_example() {
        assert_eq!(part1(&parse(EXAMPLE)), 3);
    }

    #[test]
    fn part2_example() {
        assert_eq!(part2(&parse(EXAMPLE)), 0);
    }
}