Advent of Code 2022 - Day 13 - Python

from ast import literal_eval
from functools import cmp_to_key
from itertools import zip_longest
from typing import Optional, Iterable, Union
from enum import IntEnum


DistressSignal = Optional[Union[Iterable, int]]


class Result(IntEnum):
    Ordered = -1
    Unordered = 0
    Undetermined = 1


def parse_distress_signal(filepath) -> DistressSignal:
    distress_signals = []
    with open(filepath, "r") as f:
        for chunk in f.read().split("\n\n"):
            lhs, rhs = chunk.split("\n")
            distress_signals.append([literal_eval(lhs), literal_eval(rhs)])
    return distress_signals


def flatten_distress_signals(signals) -> list[DistressSignal]:
    flattened = []
    for pair in signals:
        flattened.extend(pair)
    return flattened


def analyze_signal(signal: DistressSignal) -> Result:
    for (lhs, rhs) in zip_longest(*signal):
        match (lhs, rhs):
            case (list(), list()):
                if (result := analyze_signal((lhs, rhs))) is Result.Undetermined:
                    continue
                else:
                    return result

            case (int(), list()):
                if (result := analyze_signal(([lhs], rhs))) is Result.Undetermined:
                    continue
                else:
                    return result

            case (list(), int()):
                if (result := analyze_signal((lhs, [rhs]))) is Result.Undetermined:
                    continue
                else:
                    return result

            case (int(), int()):
                if lhs < rhs:
                    return Result.Ordered
                elif lhs == rhs:
                    continue
                elif lhs > rhs:
                    return Result.Unordered

            case (int(), None) | (list(), None):
                return Result.Unordered

            case (None, int()) | (None, list()):
                return Result.Ordered

            case (None, None):
                return Result.Undetermined

            case _:
                raise Exception("What the hell am I doin' here?\nI don't belong here?")

    return Result.Undetermined


def part_one(filepath) -> int:
    signal = parse_distress_signal(filepath)
    total = 0
    for i, pair in enumerate(signal, 1):
        if analyze_signal(pair) is Result.Ordered:
            total += i
    return total


def part_two(filepath) -> int:
    signals = parse_distress_signal(filepath)
    flattened_signal = flatten_distress_signals(signals)
    divs = [[[2]], [[6]]]
    flattened_signal.extend(divs)
    flattened_signal.sort(key=cmp_to_key(lambda x, y: analyze_signal((x, y))))
    return (flattened_signal.index(divs[0]) + 1) * (flattened_signal.index(divs[1]) + 1)