day 11

use itertools::Itertools;

#[derive(Debug, Clone)]
struct Monkey{
    items: Vec<u32>,
    op: op,
    test: u32,
    testTruePass: usize,
    testFalsePass: usize
}

#[derive(Debug, Clone)]
enum op{
    mul(u32),
    add(u32),
    square
}


pub fn day11_1(){
    let mut monkeys = include_str!("../../input11").split("\n\n").map(|x |
        {
            let mut monkey = x.lines().skip(1);
            let items = monkey.next().unwrap().split_at(18).1.split(", ").map(|x| x.parse::<u32>().unwrap()).collect_vec();
            let opTemp = monkey.next().unwrap();
            let op: op = match opTemp.as_bytes()[23] as char {
                '*' => {
                    if opTemp.ends_with("old")
                    {
                        op::square
                    }
                    else {
                        op::mul(opTemp.split_at(25).1.parse::<u32>().unwrap())
                    }
                },
                '+' => {op::add(opTemp.split_at(25).1.parse::<u32>().unwrap())},
                _ => {panic!()}
            };
            let test = monkey.next().unwrap().split_at(21).1.parse::<u32>().unwrap();
            let testTruePass = monkey.next().unwrap().split_at(29).1.parse::<usize>().unwrap();
            let testFalsePass = monkey.next().unwrap().split_at(30).1.parse::<usize>().unwrap();
            (Monkey { items, op, test, testTruePass, testFalsePass }, 0)
        }).collect_vec();
    for _ in 0..20 {
        for i in 0..monkeys.len() {
            let mut monkey = monkeys[i].0.clone();
            monkeys[i].1 += monkey.items.len();
            for mut item in monkey.items {
                match monkey.op {
                    op::mul(a) => {item *= a}
                    op::add(a) => {item += a}
                    op::square => {item *= item}
                }
                item /= 3;
                if item % monkey.test == 0 {
                    monkeys[monkey.testTruePass].0.items.push(item);
                }
                else {
                    monkeys[monkey.testFalsePass].0.items.push(item);
                }
            }
            monkeys[i].0.items = Default::default();
        }
    }
    let mut counts = monkeys.iter().map(|&(_, i)| i ).collect_vec();
    counts.sort();
    counts.reverse();
    println!("{}", counts[0] * counts[1]);
}


#[derive(Debug, Clone)]
struct Monkey2{
    items: Vec<u64>,
    op: op2,
    test: u64,
    testTruePass: usize,
    testFalsePass: usize
}

#[derive(Debug, Clone)]
enum op2{
    mul(u64),
    add(u64),
    square
}
// i have to keep track of all the modulo not the actual number, for all of the primes somehow
pub fn day11_2(){
    //hardcoding the divisor tests for now
    let mut magicNum: u64 = 1;
    let mut monkeys = include_str!("../../input11").split("\n\n").map(|x |
        {
            let mut monkey = x.lines().skip(1);
            let items = monkey.next().unwrap().split_at(18).1.split(", ").map(|x| x.parse::<u64>().unwrap()).collect_vec();
            let opTemp = monkey.next().unwrap();
            let op: op2 = match opTemp.as_bytes()[23] as char {
                '*' => {
                    if opTemp.ends_with("old")
                    {
                        op2::square
                    }
                    else {
                        op2::mul(opTemp.split_at(25).1.parse::<u64>().unwrap())
                    }
                },
                '+' => {op2::add(opTemp.split_at(25).1.parse::<u64>().unwrap())},
                _ => {panic!()}
            };
            let test = monkey.next().unwrap().split_at(21).1.parse::<u64>().unwrap();
            let testTruePass = monkey.next().unwrap().split_at(29).1.parse::<usize>().unwrap();
            let testFalsePass = monkey.next().unwrap().split_at(30).1.parse::<usize>().unwrap();
            magicNum *= test;
            (Monkey2 { items, op, test, testTruePass, testFalsePass }, 0)
        }).collect_vec();
    for _ in 0..10000 {
        for i in 0..monkeys.len() {
            let mut monkey = monkeys[i].0.clone();
            monkeys[i].1 += monkey.items.len();
            for mut item in monkey.items {
                item %= magicNum;
                match monkey.op {
                    op2::mul(a) => {item *= a}
                    op2::add(a) => {item += a}
                    op2::square => {item *= item}
                }
                if item % monkey.test == 0 {
                    monkeys[monkey.testTruePass].0.items.push(item);
                }
                else {
                    monkeys[monkey.testFalsePass].0.items.push(item);
                }
            }
            monkeys[i].0.items = Default::default();
        }
    }
    let mut counts = monkeys.iter().map(|&(_, i)| i ).collect_vec();
    counts.sort();
    counts.reverse();
    println!("{}", counts[0] * counts[1]);

}