app [main!] { pf: platform "https://github.com/lukewilliamboswell/roc-platform-template-zig/releases/download/0.6/2BfGn4M9uWJNhDVeMghGeXNVDFijMfPsmmVeo6M4QjKX.tar.zst" }

import pf.Stdout

main! = |_args| {
    input =
        \\two1nine
        \\eightwothree
        \\abcone2threexyz
        \\xtwone3four
        \\4nineeightseven2
        \\zoneight234
        \\7pqrstsixteen

    part1(input)?->Stdout.line!()

    # answer1 = part1(input)?#->debug()->debug()->debug()
    # Stdout.line!(answer1)

    # answer2 = part2(input)?#->debug()->debug()->debug()
    # Stdout.line!(answer2)

    Ok({})
}

## Solve part 1
part1 : Str -> Try(Str, _)
part1 = |s| {
    s.split_on("\n")
    .map(extract_digits)
    ->keep_oks(compute_calibration)
    # ->debug() # (1)
    ->sum()
    # ->debug() # (2)
    .to_str()
    # ->debug() # (3)
    ->Ok
    # ->debug() # (4)
}

extract_digits : Str -> List(U64)
extract_digits = |s| {
    s.to_utf8()
        .keep_if(|c| c >= '0' and c <= '9')
        .map(|c| (c - '0').to_u64())
}

compute_calibration : List(U64) -> Try(U64, _)
compute_calibration = |digits| Ok(List.first(digits)? * 10 + List.last(digits)?)

## Solve part 2
part2 : Str -> Try(Str, _)
part2 = |s| {
    s.split_on("\n")
        .map(extract_text_digits)
        ->keep_oks(compute_calibration)
        ->debug()
        ->sum()
        .to_str()
        ->Ok
}

extract_text_digits : Str -> List(U64)
extract_text_digits = |s| {
    bytes = s.to_utf8()
    0.U64.to(bytes.len())
        .fold(
            [],
            |ds, i| {
                match bytes.drop_first(i) {
                    ['o', 'n', 'e', ..] => ds.append(1)
                    ['t', 'w', 'o', ..] => ds.append(2)
                    ['t', 'h', 'r', 'e', 'e', ..] => ds.append(3)
                    ['f', 'o', 'u', 'r', ..] => ds.append(4)
                    ['f', 'i', 'v', 'e', ..] => ds.append(5)
                    ['s', 'i', 'x', ..] => ds.append(6)
                    ['s', 'e', 'v', 'e', 'n', ..] => ds.append(7)
                    ['e', 'i', 'g', 'h', 't', ..] => ds.append(8)
                    ['n', 'i', 'n', 'e', ..] => ds.append(9)
                    ['z', 'e', 'r', 'o', ..] => ds.append(0)
                    [d, ..] => if d >= '0' and d <= '9' ds.append((d - '0').to_u64()) else ds
                    [] => ds
                }
            },
        )
}

keep_oks : List(a), (a -> Try(b, e)) -> List(b)
keep_oks = |vs, f| {
    vs.fold(
        [],
        |acc, v| {
            match f(v) {
                Ok(u) => acc.append(u)
                Err(_) => acc
            }
        },
    )
}

sum : List(Num) -> Num
sum = |nums| nums.fold(0, |acc, n| acc + n)

debug : a -> a
debug = |v| {
    dbg v
    v
}

range_to : Num, Num -> List(Num)
range_to = |var $current, end| {
    var $list = []

    while $current <= end {
        $list = $list.append($current)
        $current = $current + 1
    }

    $list
}