use color_eyre::Result;

#[derive(Clone, Debug)]
enum Color {
    Red,
    Green,
    Blue,
}

#[derive(Clone, Debug)]
struct Game {
    bags: Vec<Bag>,
}

impl Game {
    fn new() -> Self {
        Game { bags: Vec::new() }
    }
}

#[derive(Clone, Debug, Default)]
struct Bag {
    red: u32,
    green: u32,
    blue: u32,
}

impl Bag {
    fn new(red: u32, green: u32, blue: u32) -> Self {
        Bag { red, green, blue }
    }

    fn add_red(&mut self, num: u32) {
        self.red += num;
    }

    fn add_green(&mut self, num: u32) {
        self.green += num;
    }

    fn add_blue(&mut self, num: u32) {
        self.blue += num;
    }
}

fn parse_color(color: &str) -> Option<Color> {
    let color = color.to_lowercase();
    if color.contains("red") {
        Some(Color::Red)
    } else if color.contains("green") {
        Some(Color::Green)
    } else if color.contains("blue") {
        Some(Color::Blue)
    } else {
        None
    }
}

fn parse_line(line: &str) -> Result<Game> {
    let mut parts: Vec<_> = line.split(|c| c == ';' || c == ':').collect();
    parts.remove(0);

    let mut game = Game::new();

    parts.iter().for_each(|part| {
        let colors: Vec<_> = part.split_whitespace().collect();
        let mut bag = Bag::default();
        for chunk in colors.chunks_exact(2).into_iter() {
            if let Some(parsed_color) = parse_color(chunk[1]) {
                if let Ok(amount) = chunk.get(0).unwrap_or(&"ID not found").parse::<u32>() {
                    match parsed_color {
                        Color::Red => bag.add_red(amount),
                        Color::Green => bag.add_green(amount),
                        Color::Blue => bag.add_blue(amount),
                    }
                }
            }
        }
        game.bags.push(bag);
    });

    Ok(game)
}

pub fn process(input: &str) -> Result<u32> {
    let games: Vec<Game> = input.lines().flat_map(|line| parse_line(line)).collect();
    let sum: u32 = games
        .iter()
        .map(|game| {
            let max_bag = game.bags.iter().cloned().fold(Bag::default(), |acc, bag| {
                Bag::new(
                    acc.red.max(bag.red),
                    acc.green.max(bag.green),
                    acc.blue.max(bag.blue),
                )
            });
            max_bag.red * max_bag.green * max_bag.blue
        })
        .sum();
    Ok(sum)
}

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

    #[test]
    fn test_process() -> Result<()> {
        let input = "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green";
        assert_eq!(2286, process(input)?);
        Ok(())
    }
}