use aoc_runner_derive::{aoc, aoc_generator};

#[derive(Debug, PartialEq, Eq, Ord, PartialOrd)]
pub struct Rule {
    min: usize,
    max: usize,
    ch: char,
    pw: String,
}

impl Rule {
    fn is_valid_part1(&self) -> bool {
        let n = self.pw.chars().filter(|c| *c == self.ch).count();
        return n >= self.min && n <= self.max;
    }
    fn is_valid_part2(&self) -> bool {
        let idx_1 = self.min - 1;
        let idx_2 = self.max - 1;
        let chars: Vec<char> = self.pw.chars().collect();
        return (chars.get(idx_1) == Some(&self.ch)) ^ (chars.get(idx_2) == Some(&self.ch));
    }
}

#[aoc_generator(day2)]
pub fn input_generator(input: &str) -> Vec<Rule> {
    input
        .lines()
        .map(|l| {
            let mut ws = l.trim().split_whitespace();
            let range = ws.next().unwrap();
            let ch = ws
                .next()
                .unwrap()
                .trim_end_matches(|c| c == ':')
                .chars()
                .next()
                .unwrap();
            let pw = ws.next().unwrap().to_owned();
            let (r_min, r_max) = {
                let mut r = range.split('-');
                let r_min = r.next().unwrap().parse().unwrap();
                let r_max = r.next().unwrap().parse().unwrap();
                (r_min, r_max)
            };
            Rule {
                min: r_min,
                max: r_max,
                ch,
                pw,
            }
        })
        .collect::<Vec<Rule>>()
}

#[aoc(day2, part1)]
pub fn solve_part1(input: &Vec<Rule>) -> usize {
    let mut total = 0;
    for rule in input {
        if rule.is_valid_part1() {
            total += 1;
        }
    }
    total
}

#[aoc(day2, part2)]
pub fn solve_part2(input: &Vec<Rule>) -> usize {
    let mut total = 0;
    for rule in input {
        if rule.is_valid_part2() {
            total += 1;
        }
    }
    total
}