parseNumberColor : Parser (List U8) [Red U32, Green U32, Blue U32]
parseNumberColor =
    const (\number -> \color ->
        when color is
            Red -> Red number
            Green -> Green number
            Blue -> Blue number
    )
    |> keep (digits |> Core.map Num.toU32)
    |> skip (codeunit ' ')
    |> keep (Core.oneOf [
        string "red" |> Core.map \_ -> Red,
        string "green" |> Core.map \_ -> Green,
        string "blue" |> Core.map \_ -> Blue,
    ])

expect parseStr parseNumberColor "64 green" == Ok (Green 64u32)
expect parseStr parseNumberColor "12 red" == Ok (Red 12u32)
expect parseStr parseNumberColor "546 blue" == Ok (Blue 546u32)

app "day2"
    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 },
        Util.{allLines},
        Num.{max},
    ]
    provides [main] to pf

main =
    lines <- allLines |> Task.await
    optGames = List.mapTry lines parseGame
    when optGames is
      Ok games -> (
          {} <- part1 games |> Num.toStr |> Stdout.line |> Task.await
          part2 games |> Num.toStr |> Stdout.line
      )
      Err _ -> Stdout.line "bad input"

Game : { id: Nat, sets: List GameSet }
GameSet : {red: Nat, green: Nat, blue: Nat}

parseGame : Str -> Result Game [InvalidNumStr, NotFound, UnknownColour Str]
parseGame = \line ->
    {before: ghead, after: gameSets} <- Str.splitFirst line ": " |> Result.try
    {after: strID}                   <- Str.splitFirst ghead " " |> Result.try
    natID                            <- Str.toNat strID          |> Result.try
    sets <-   List.mapTry (Str.split gameSets "; ") parseGameSet |> Result.try
    Ok {id: natID, sets: sets}

emptySet : GameSet
emptySet = {red: 0, green: 0, blue: 0}

joinSets : GameSet, GameSet -> GameSet
joinSets = \x, y ->
    { red: max x.red y.red,
      green: max x.green y.green,
      blue: max x.blue y.blue }

parseGameSet : Str -> Result GameSet [InvalidNumStr, NotFound, UnknownColour Str]
parseGameSet = \set ->
    subSets <- List.mapTry (Str.split set ", ") (\x ->
      {before: strCount, after: colour} <- Str.splitFirst x " " |> Result.try
      count                             <- Str.toNat strCount   |> Result.try
      when colour is
        "red" ->   Ok {emptySet & red:   count}
        "green" -> Ok {emptySet & green: count}
        "blue" ->  Ok {emptySet & blue:  count}
        _ -> Err (UnknownColour colour)
    ) |> Result.try
    List.walk subSets emptySet joinSets |> Ok


isSubset : GameSet, GameSet -> Bool
isSubset = \x, y ->
  x.red <= y.red && x.green <= y.green && x.blue <= y.blue

elfBag : GameSet
elfBag = {red: 12, green: 13, blue: 14}

part1 : List Game -> Nat
part1 = \games ->
  possibleGames = List.keepIf games (\x -> List.all x.sets
                                           (\set -> isSubset set elfBag))
  List.map possibleGames .id |> List.sum

gameCube : Game -> Nat
gameCube = \game ->
  {red: r, green: g, blue: b} = List.walk game.sets emptySet joinSets
  r*g*b

part2 : List Game -> Nat
part2 = \games ->
  List.map games gameCube |> List.sum

app "AoC"
    packages {
        pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br",
        parser: "https://github.com/lukewilliamboswell/roc-parser/releases/download/0.2.0/dJQSsSmorujhiPNIvJKlQoI92RFIG_JQwUfIxZsCSwE.tar.br",
    }
    imports [
        pf.Stdout,
        pf.Task.{ Task },
        parser.Core.{
            Parser,
            const, keep, skip, sepBy, oneOf
        },
        parser.String.{
            digits, string, parseStr
        },
        "day-2-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 parseGame
    |> List.keepIf (\game -> possible game { red: 12, green: 13, blue: 14 })
    |> List.map .id
    |> List.sum
    |> Num.toStr

possible = \game, {red, green, blue} ->
    reqPossible = \req -> when req is
        Green g -> green >= g
        Red r -> red >= r
        Blue b -> blue >= b
    reqSetPossible = \reqSet -> List.all reqSet reqPossible
    List.all game.requirements reqSetPossible

part2 : Str
part2 =
    input
    |> Str.split "\n"
    |> List.dropIf Str.isEmpty
    |> List.map parseGame
    |> List.map fewest
    |> List.map power
    |> List.sum
    |> Num.toStr

fewest = \game ->
    reqFewest = \{red, green, blue}, req ->
        when req is
            Green g -> { red, blue, green: Num.max green g }
            Red r -> { green, blue, red: Num.max red r }
            Blue b -> { red, green, blue: Num.max blue b }
    reqSetFewest = \accum, reqSet ->
        List.walk reqSet accum reqFewest
    List.walk game.requirements { red: 0, green: 0, blue: 0 } reqSetFewest

power = \{red, green, blue} -> red * green * blue

Requirement : [ Green Nat, Red Nat, Blue Nat ]
RequirementSet : List Requirement
Game : { id: Nat, requirements: List RequirementSet }

parseGame : Str -> Game
parseGame = \s ->
    green = const Green |> keep digits |> skip (string " green")
    red = const Red |> keep digits |> skip (string " red")
    blue = const Blue |> keep digits |> skip (string " blue")

    requirementSet : Parser _ RequirementSet
    requirementSet = (oneOf [green, red, blue]) |> sepBy (string ", ")

    requirements : Parser _ (List RequirementSet)
    requirements = requirementSet |> sepBy (string "; ")

    game = const (\id -> \r -> { id, requirements: r })
        |> skip (string "Game ")
        |> keep digits
        |> skip (string ": ")
        |> keep requirements

    when parseStr game s is
        Ok g -> g
        Err (ParsingFailure e) | Err (ParsingIncomplete e) -> crash "bad input: '\(e)'"

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, "./day2-input.txt" as input : Str]
  provides [main] to pf

main =
  {} <- Stdout.line "The total sum is \(part1)" |> Task.await
  {} <- Stdout.line "The sum power is \(part2)" |> Task.await
  Task.ok {}

part1 =
  games input
  |> possibleGameIds
  |> List.keepOks Str.toU32
  |> List.sum
  |> Num.toStr

part2 =
  games input
  |> List.map minPossibleSet
  |> List.map List.product
  |> List.sum
  |> Num.toStr

games = \gamelist -> Str.split gamelist "\n"

minPossibleSet = \game ->
  gameinfo = removeGameId game
  [ (getCountsByColor gameinfo "red" |> List.max |> Result.withDefault 0)
  , (getCountsByColor gameinfo "green" |> List.max |> Result.withDefault 0)
  , (getCountsByColor gameinfo "blue" |> List.max |> Result.withDefault 0)
  ]

expect minPossibleSet "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green" == [ 4, 2, 6 ]
expect minPossibleSet "Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue" == [ 1, 3, 4 ]
expect minPossibleSet "Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red" == [ 20, 13, 6 ]

possibleGameIds = \allGames ->
  allGames
  |> List.keepIf \line -> isCountLte line 12 "red"
  |> List.keepIf \line -> isCountLte line 13 "green"
  |> List.keepIf \line -> isCountLte line 14 "blue"
  |> List.map parseGameId

isCountLte = \line, maxThreshold, color ->
  removeGameId line
  |> getCountsByColor color
  |> List.keepIf \count -> Num.isGt count maxThreshold
  |> List.isEmpty

expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 80 "blue" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 80 "red" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 80 "green" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 8 "blue" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 5 "red" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 2 "green" == Bool.true
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 1 "blue" == Bool.false
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 1 "red" == Bool.false
expect isCountLte "Game 1: 8 blue, 5 red; 2 green" 1 "green" == Bool.false


removeGameId = \line ->
  Str.split line ":"
  |> List.dropFirst 1
  |> Str.joinWith ":"

expect removeGameId "Game 1: 2 blue, 4 green; 7 blue, 1 red, 14 green; 5 blue, 13 green, 1 red; 1 red, 7 blue, 11 green" == " 2 blue, 4 green; 7 blue, 1 red, 14 green; 5 blue, 13 green, 1 red; 1 red, 7 blue, 11 green"
expect removeGameId "Game 10: 7 blue, 4 red, 11 green; 13 green, 1 red, 1 blue; 7 blue, 6 green" == " 7 blue, 4 red, 11 green; 13 green, 1 red, 1 blue; 7 blue, 6 green"


getCountsByColor = \gameinfo, color ->
  Str.replaceEach gameinfo ";" ","
  |> Str.split ","
  |> List.map Str.trim
  |> List.keepIf \pick -> (Str.endsWith pick color)
  |> List.keepOks \pick -> (Str.split pick " " |> List.first)
  |> List.keepOks Str.toU32

expect getCountsByColor " 8 red, 3 blue; 5 blue, 2 red" "red" == [ 8, 2 ]

parseGameId = \line ->
  Str.replaceFirst line "Game " ""
  |> Str.split ":"
  |> List.first
  |> Result.withDefault "Unknown"

expect parseGameId "Game 1: 2 blue, 4 green; 7 blue, 1 red, 14 green; 5 blue, 13 green, 1 red; 1 red, 7 blue, 11 green" == "1"
expect parseGameId "Game 10: 7 blue, 4 red, 11 green; 13 green, 1 red, 1 blue; 7 blue, 6 green" == "10"


# debug = \v, ctx ->
#   dbg ctx
#   dbg v
#   v

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

lines : Str -> List Str
lines = \str -> str |> Str.split "\n"

main : Task {} *
main =
    {} <- "Part 1: \(part1)" |> Stdout.line |> Task.await
    {} <- "Part 2: \(part2)" |> Stdout.line |> Task.await
    Task.ok {}

part1 = solve input

solve = \str ->
    str
        |> parse
        |> List.keepIf \(_, b) -> b
        |> List.map \(val, _) -> val
        |> List.sum
        |> Num.toStr

parse = \str ->
    str
        |> lines
        |> List.map parseLine

parseLine = \line ->
    line
        |> Str.replaceFirst "Game " ""
        |> Str.split ":"
        |> \lst ->
            when lst is
                [num, drawsStr] ->
                    gameId = num |> Str.toU32 |> Result.withDefault 0
                    possible =
                        drawsStr
                            |> Str.split ";"
                            |> List.map parseDraw
                            |> isPossibleGame
                            |> List.isEmpty
                    (gameId, possible)
                _ -> (0, Bool.false)


isPossibleGame = \drawList ->
    drawList |> List.keepErrs isPossibleDraw

isPossibleDraw = \draw ->
    isPossibleWithConstraint draw constraintPart1

isPossibleWithConstraint = \draw, constraint ->
    when constraint draw is
        Possible -> Ok draw
        Impossible -> Err "Impossible game"

constraintPart1 = \draw ->
    when draw is
        {red, green, blue} if red <= 12 && green <= 13 && blue <= 14 -> Possible
        _ -> Impossible



parseDraw = \str ->
    str
        |> Str.split ","
        |> List.map Str.trim
        |> List.map (\s -> Str.split s " ")
        |> List.map \lst ->
            when lst is
            [num, color] ->
                number = num |> Str.toU32 |> Result.withDefault 0
                (number, color)
            _ -> (0, "red")
        |> List.walk emptyDraw \state, (num, color) ->
                when color is
                    "red" -> {state & red: state.red + num}
                    "green" -> {state & green: state.green + num}
                    "blue" -> {state & blue: state.blue + num}
                    _ -> state

emptyDraw = {red: 0, green: 0, blue: 0}

part2 = solve2 input

solve2 = \str ->
    str
        |> parse2
        |> List.map power
        |> List.sum
        |> Num.toStr

power = \{red, green, blue} -> red * green * blue

parse2 = \str ->
    str
        |> lines
        |> List.map parseLine2

parseLine2 = \line ->
    line
        |> Str.replaceFirst "Game " ""
        |> Str.split ":"
        |> \lst ->
            when lst is
                [_, drawsStr] ->
                    drawsStr
                        |> Str.split ";"
                        |> List.map parseDraw
                        |> minimumContent
                _ -> emptyDraw

minimumContent = \drawList ->
    drawList |> List.walk emptyDraw \state, draw ->
        {
            red: Num.max state.red draw.red,
            green: Num.max state.green draw.green,
            blue: Num.max state.blue draw.blue
        }

expect
    expected = {green : 8, blue: 6, red: 20}
    parsed = parseDraw exampleDraw
    parsed == expected

expect
    expected = Err "Impossible game"
    possible = parseDraw exampleDraw |> isPossibleDraw
    possible == expected

expect
    expected = [(1, Bool.true), (2, Bool.true), (3, Bool.false), (4, Bool.false), (5, Bool.true)]
    parsed = parse example
    parsed == expected

expect
    expected = "8"
    solved = solve example
    solved == expected

example =
    """
    Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
    Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
    Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
    Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
    Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
    """

exampleDraw = "8 green, 6 blue, 20 red"


expect
    expectedMinimum = [
        {red: 4, green: 2, blue: 6},
        {red: 1, green: 3, blue: 4},
        {red: 20, green: 13, blue: 6},
        {red: 14, green: 3, blue: 15},
        {red: 6, green: 3, blue: 2},
    ]
    actualMinimum = parse2 example
    expectedMinimum == actualMinimum

expect
    expectedSolve = "2286"
    actualSolve = solve2 example
    expectedSolve == actualSolve