#![feature(test)]
use std::{collections::HashSet, env};
extern crate test;

const COLOR: &str = "shiny gold";

fn main() {
    let input = parse_input(&read_input());
    println!("Part 1: {}", part1(&input, COLOR, &mut HashSet::new()).len());
    println!("Part 2: {}", part2(&input, COLOR));
}

#[derive(Debug)]
struct Bag {
    color:    String,
    contents: Vec<InnerBag>,
}

#[derive(Debug)]
struct InnerBag {
    qty:   usize,
    color: String,
}

// this is dumb
impl From<&str> for Bag {
    fn from(raw: &str) -> Self {
        let mut split = raw.split(", ");
        Self {
            color:    split.next().unwrap().to_string(),
            contents: split
                .filter_map(|s| {
                    if s.starts_with("no other") {
                        None
                    } else {
                        let mut split = s.splitn(2, ' ');
                        Some(InnerBag {
                            qty:   split.next().unwrap().parse().unwrap(),
                            color: split.next().unwrap().to_owned(),
                        })
                    }
                })
                .collect(),
        }
    }
}

fn read_input() -> String {
    std::fs::read_to_string(
        env::args()
            .nth(1)
            .filter(|n| n != "--bench")
            .unwrap_or_else(|| String::from("inputs/day07")),
    )
    .unwrap()
}

fn part1<'a, 'b>(bags: &'b [Bag], color: &str, seen: &'a mut HashSet<&'b str>) -> &'a mut HashSet<&'b str> {
    for bag in bags.iter().filter(|bag| bag.contents.iter().any(|b| b.color == color)) {
        seen.insert(&bag.color);
        part1(bags, &bag.color, seen);
    }
    seen
}

fn part2(bags: &[Bag], color: &str) -> usize {
    bags.iter()
        .filter(|bag| bag.color == color)
        .map(|bag| bag.contents.iter().map(|c| (part2(bags, &c.color) * c.qty) + c.qty).sum::<usize>())
        .sum()
}

fn parse_input(s: &str) -> Vec<Bag> {
    s.replace(" bags contain", ",")
        .replace(" bags", "")
        .replace(" bag", "")
        .replace('.', "")
        .lines()
        .map(Bag::from)
        .collect()
}

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

    const TEST_INPUT: &str = "light red bags contain 1 bright white bag, 2 muted yellow bags.
dark orange bags contain 3 bright white bags, 4 muted yellow bags.
bright white bags contain 1 shiny gold bag.
muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.
shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.
dark olive bags contain 3 faded blue bags, 4 dotted black bags.
vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.
faded blue bags contain no other bags.
dotted black bags contain no other bags.";

    #[test]
    fn part1_test() {
        let input = parse_input(TEST_INPUT);
        assert_eq!(part1(&input, COLOR, &mut HashSet::new()).len(), 4);
    }

    const TEST_INPUT_2: &str = "shiny gold bags contain 2 dark red bags.
dark red bags contain 2 dark orange bags.
dark orange bags contain 2 dark yellow bags.
dark yellow bags contain 2 dark green bags.
dark green bags contain 2 dark blue bags.
dark blue bags contain 2 dark violet bags.
dark violet bags contain no other bags.";

    #[test]
    fn part2_test() {
        let input = parse_input(TEST_INPUT);
        assert_eq!(part2(&input, COLOR), 32);
        let input = parse_input(TEST_INPUT_2);
        assert_eq!(part2(&input, COLOR), 126);
    }

    #[bench]
    fn bench_input_parsing(b: &mut test::Bencher) {
        let raw = read_input();
        b.iter(|| assert_eq!(parse_input(black_box(&raw)).len(), 594))
    }

    #[bench]
    fn bench_part1(b: &mut test::Bencher) {
        let bags = parse_input(&read_input());
        b.iter(|| assert_eq!(part1(black_box(&bags), COLOR, &mut HashSet::new()).len(), 226))
    }

    #[bench]
    fn bench_part2(b: &mut test::Bencher) {
        let bags = parse_input(&read_input());
        b.iter(|| assert_eq!(part2(black_box(&bags), COLOR), 9569))
    }
}