prefixes = \str, soFar ->
    if Str.isEmpty str then
        soFar

    else
        next = str
            |> Str.graphemes
            |> List.dropFirst 1
            |> Str.joinWith ""

        prefixes next (List.append soFar str)


expect prefixes "abc" [] == ["abc", "c", ""] # passes
expect prefixes "abc" [] == ["abc", "bc", "c"] # fails

s
|> Str.graphemes
|> List.dropFirst 1
|> Str.joinWith ""

app "hello"
    packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" }
    imports [pf.Stdout, pf.Task, "./day1-input.txt" as input : Str]
    provides [main] to pf

main =
    {} <- Stdout.line "The total sum is \(part1)" |> Task.await
    {} <- Stdout.line "Wait, no... it's \(part2)" |> Task.await

    Task.ok {}

part1 = sumNums input |> Num.toStr
part2 = repairDoc input |> sumNums |> Num.toStr

repairDoc = \doc ->
    # Words are overlapped throughout, e.g. twone is 21
    # Replacing each with a digit, but keeping the full
    # original word intact to allow all overlaps
    Str.replaceEach doc "one" "one1one"
    |> Str.replaceEach "two" "two2two"
    |> Str.replaceEach "three" "three3three"
    |> Str.replaceEach "four" "four4four"
    |> Str.replaceEach "five" "five5five"
    |> Str.replaceEach "six" "six6six"
    |> Str.replaceEach "seven" "seven7seven"
    |> Str.replaceEach "eight" "eight8eight"
    |> Str.replaceEach "nine" "nine9nine"

sumNums = \doc ->
    Str.split doc "\n"
    |> List.map \line -> parseLine line
    |> List.sum

parseLine = \line ->
    Str.graphemes line
    |> List.keepOks Str.toU32
    |> \numList -> (10 * Result.withDefault (List.first numList) 0) + (Result.withDefault (List.last numList) 0)

debug = \v ->
    dbg v
    v

app "AoC"
    packages {
        pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br",
    }
    imports [pf.Stdout, pf.Task.{ Task }, "day-1-input.txt" as input : Str]
    provides [main] to pf

main : Task {} *
main =
    Stdout.line part1
    |> Task.await \_ -> Stdout.line part2

part1 : Str
part1 =
    input
    |> Str.split "\n"
    |> List.dropIf Str.isEmpty
    |> List.map Str.toUtf8
    |> List.map (\ds -> determineCalibration ds Bool.false)
    |> List.sum
    |> Num.toStr

part2 : Str
part2 =
    input
    |> Str.split "\n"
    |> List.dropIf Str.isEmpty
    |> List.map Str.toUtf8
    |> List.map (\ds -> determineCalibration ds Bool.true)
    |> List.sum
    |> Num.toStr

determineCalibration = \digits, word ->
    first = firstDigit digits word
    last = lastDigit digits word
    Num.toU64 (10*first + last)

firstDigit = \digitsIn, word ->
    go = \digits ->
        when digits is
            [n, ..] if n >= '0' && n <= '9' -> n - '0'
            ['o','n','e', ..]         if word -> 1
            ['t','w','o', ..]         if word -> 2
            ['t','h','r','e','e', ..] if word -> 3
            ['f','o','u','r', ..]     if word -> 4
            ['f','i','v','e', ..]     if word -> 5
            ['s','i','x', ..]         if word -> 6
            ['s','e','v','e','n', ..] if word -> 7
            ['e','i','g','h','t', ..] if word -> 8
            ['n','i','n','e', ..]     if word -> 9
            [_, .. as rest] -> go rest
            [] -> crash "No firstDigitits left"
    go digitsIn

lastDigit = \digitsIn, word ->
    go = \digits ->
        when digits is
            [.., n] if n >= '0' && n <= '9' -> n - '0'
            [.., 'o','n','e']         if word -> 1
            [.., 't','w','o']         if word -> 2
            [.., 't','h','r','e','e'] if word -> 3
            [.., 'f','o','u','r']     if word -> 4
            [.., 'f','i','v','e']     if word -> 5
            [.., 's','i','x']         if word -> 6
            [.., 's','e','v','e','n'] if word -> 7
            [.., 'e','i','g','h','t'] if word -> 8
            [.., 'n','i','n','e']     if word -> 9
            [.. as rest, _] -> go rest
            [] -> crash "No firstDigitits left"
    go digitsIn

app "day1"
    packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" }
    imports [
        pf.Stdout,
        pf.Stdin,
        pf.Task.{ Task },
    ]
    provides [main] to pf

main =
    lines <- allLines |> Task.await
    {} <- problem1 lines |> Num.toStr |> Stdout.line |> Task.await
    problem2 lines |> Num.toStr |> Stdout.line

digits = [
    ("1", 1),
    ("2", 2),
    ("3", 3),
    ("4", 4),
    ("5", 5),
    ("6", 6),
    ("7", 7),
    ("8", 8),
    ("9", 9),
  ]

wordDigits = [
    ("one",   1),
    ("two",   2),
    ("three", 3),
    ("four",  4),
    ("five",  5),
    ("six",   6),
    ("seven", 7),
    ("eight", 8),
    ("nine",  9),
  ]


problem1Assoc = digits
problem2Assoc = List.concat digits wordDigits

problem1 : List Str -> Nat
problem1 = \x ->
  solveWith problem1Assoc x

problem2 : List Str -> Nat
problem2 = \x ->
  solveWith problem2Assoc x

solveWith : List (Str, Nat), List Str -> Nat
solveWith = \assoc, xs ->
  List.map xs (\x -> solve1 assoc x) |> List.sum

solve1 : List (Str, Nat), Str -> Nat
solve1 = \assoc, line ->
  results = prefixes line |> List.keepOks (\x -> digitFromPrefix assoc x)
  when (List.first results, List.last results) is
    (Ok a, Ok b) -> a*10 + b
    _ -> 0

digitFromPrefix : List (Str, Nat), Str -> Result Nat [NotFound]
digitFromPrefix = \assoc, prefix ->
  List.walkUntil assoc (Err NotFound) (\_, (k, v) ->
    if Str.startsWith prefix k then
      Break (Ok v)
    else Continue (Err NotFound)
  )

# Something funny's going on inside the Roc runtime:
# https://github.com/roc-lang/roc/issues/6139

prefixes : Str -> List Str
prefixes = \s ->
  lst = Str.graphemes s
  len = List.len lst

  List.range {start: At len, end: At 1} |>
  List.map (\x -> List.takeLast lst x) |>
  List.map (\x -> Str.joinWith x "")

allLines : Task (List Str) *
allLines =
   Task.loop [] (\xs ->
     cur <- Task.await Stdin.line
     when cur is
       Input line -> List.append xs line |> Step |> Task.ok
       End -> Done xs |> Task.ok
   )