AlexAegis/advent-of-code

import { isNotNullish, split } from '@alexaegis/advent-of-code-lib';

export type MonkeyOperation = (wl: number) => number;

export interface Monkey {
    id: number;
    items: number[];
    operation: MonkeyOperation;
    test: number;
    trueTarget: number;
    falseTarget: number;
    inspects: number;
}

export class MonkeyBuilder {
    id?: number;
    items: number[] = [];
    operation?: MonkeyOperation;
    test?: number;
    trueTarget?: number;
    falseTarget?: number;

    setId(id: number): void {
        this.id = id;
    }

    setItems(items: number[]): void {
        this.items = items;
    }

    setTest(test: number): void {
        this.test = test;
    }

    setOperation(operation: MonkeyOperation): void {
        this.operation = operation;
    }

    setTrueTarget(trueTarget: number): void {
        this.trueTarget = trueTarget;
    }

    setFalseTarget(falseTarget: number): void {
        this.falseTarget = falseTarget;
    }

    build(): Monkey {
        if (
            this.id !== undefined &&
            this.test !== undefined &&
            this.operation !== undefined &&
            this.falseTarget !== undefined &&
            this.trueTarget !== undefined
        ) {
            return {
                id: this.id,
                test: this.test,
                operation: this.operation,
                items: this.items,
                inspects: 0,
                falseTarget: this.falseTarget,
                trueTarget: this.trueTarget,
            };
        } else {
            throw new Error('Monkey not buildable!');
        }
    }
}

export const parse = (input: string): { monkeyMap: Record<number, Monkey>; monkeys: Monkey[] } => {
    const lines = split(input, true);
    const monkeyMap: Record<number, Monkey> = {};

    const monkeyIdMatcher = /^Monkey (\d+):$/;
    const monkeyStartingItemMatcher = /^ *Starting items: (.+)$/;
    const monkeyOperationMatcher = /^ *Operation: new = (.+)$/;
    const monkeyTestMatcher = /^ *Test: divisible by (\d+)$/;
    const monkeyTrueTargetMatcher = /^ *If true: throw to monkey (\d+)$/;
    const monkeyFalseTargetMatcher = /^ *If false: throw to monkey (\d+)$/;

    let monkeyBuilder = new MonkeyBuilder();
    for (const line of lines) {
        if (!line) {
            const monkey = monkeyBuilder.build();
            monkeyMap[monkey.id] = monkey;
            monkeyBuilder = new MonkeyBuilder();
            continue;
        }

        const monkeyIdMatch = monkeyIdMatcher.exec(line)?.[1]?.toInt();
        if (isNotNullish(monkeyIdMatch)) {
            monkeyBuilder.setId(monkeyIdMatch);
            continue;
        }

        const monkeyStartingItemMatch = monkeyStartingItemMatcher.exec(line)?.[1];
        if (monkeyStartingItemMatch) {
            monkeyBuilder.setItems(monkeyStartingItemMatch.split(', ').toInt());
            continue;
        }

        const monkeyOperationMatch = monkeyOperationMatcher.exec(line)?.[1];
        if (monkeyOperationMatch) {
            monkeyBuilder.setOperation(eval('old => ' + monkeyOperationMatch) as MonkeyOperation);
            continue;
        }

        const monkeyTestMatch = monkeyTestMatcher.exec(line)?.[1]?.toInt();
        if (isNotNullish(monkeyTestMatch)) {
            monkeyBuilder.setTest(monkeyTestMatch);
            continue;
        }

        const monkeyTrueTargetMatch = monkeyTrueTargetMatcher.exec(line)?.[1]?.toInt();
        if (isNotNullish(monkeyTrueTargetMatch)) {
            monkeyBuilder.setTrueTarget(monkeyTrueTargetMatch);
            continue;
        }

        const monkeyFalseTargetMatch = monkeyFalseTargetMatcher.exec(line)?.[1]?.toInt();
        if (isNotNullish(monkeyFalseTargetMatch)) {
            monkeyBuilder.setFalseTarget(monkeyFalseTargetMatch);
            continue;
        }
    }

    return { monkeyMap, monkeys: Object.values(monkeyMap) };
};