app [main] {
    pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.15.0/SlwdbJ-3GR7uBWQo6zlmYWNYOxnvo8r6YABXD-45UOw.tar.br",
    aoc: "https://github.com/lukewilliamboswell/aoc-template/releases/download/0.1.0/DcTQw_U67F22cX7pgx93AcHz_ShvHRaFIFjcijF3nz0.tar.br",
}

import pf.Stdin
import pf.Stdout
import pf.Utc
import aoc.AoC {
    stdin: Stdin.bytes,
    stdout: Stdout.write,
    time: \{} -> Utc.now {} |> Task.map Utc.toMillisSinceEpoch,
}

main =
    AoC.solve {
        year: 2020,
        day: 1,
        title: "Report Repair",
        part1,
        part2,
    }

part1 : Str -> Result Str Str
part1 = \input ->

    numbers : List U128
    numbers = parse input

    combined : List { x : U128, y : U128, mul : U128 }
    combined =
        List.joinMap numbers \x ->
            List.keepOks numbers \y ->
                if (x + y) == 2020 then
                    Ok { x, y, mul: x * y }
                else
                    Err NotValid

    combined
    |> List.first
    |> Result.map \{ x, y, mul } -> "$(Num.toStr x) * $(Num.toStr y) = $(Num.toStr mul)"
    |> Result.mapErr \_ -> "Expected at least one pair to have sum of 2020"

part2 : Str -> Result Str Str
part2 = \input ->

    numbers : List U128
    numbers = parse input

    combined : List { x : U128, y : U128, z : U128, mul : U128 }
    combined =
        List.joinMap numbers \x ->
            List.joinMap numbers \y ->
                List.keepOks numbers \z ->
                    if (x + y + z) == 2020 then
                        Ok { x, y, z, mul: x * y * z }
                    else
                        Err NotValid

    combined
    |> List.first
    |> Result.map \{ x, y, z, mul } -> "$(Num.toStr x) * $(Num.toStr y) * $(Num.toStr z) = $(Num.toStr mul)"
    |> Result.mapErr \_ -> "Expected at least one triple to have sum of 2020"

parse : Str -> List U128
parse = \input ->
    input
    |> Str.split "\n"
    |> List.keepOks Str.toU128

expect
    result = part1 example
    result == Ok "1721 * 299 = 514579"

expect
    result = part2 example
    result == Ok "979 * 366 * 675 = 241861950"

expect parse example == [1721, 979, 366, 299, 675, 1456]

example =
    """
    1721
    979
    366
    299
    675
    1456
    """

$ roc --optimize 2020/01.roc < input/2020_01.txt
--- ADVENT OF CODE 2020-1: Report Repair ---

INPUT:
Reading input from STDIN...

PART 1:
1939 * 81 = 157059

PART 2 ERROR:
"Expected at least one triple to have sum of 2020"

TIMING:
READING INPUT:  <1ms
SOLVING PART 1: <1ms
SOLVING PART 2: 4ms
---

parse : Str -> List U128
parse = \input ->
    input
    |> Str.split "\n"
    |> \lines ->
        dbg List.len lines
        lines
    |> List.keepOks Str.toU128
    |> \numbers ->
        dbg List.len numbers
        numbers

[2020/01.roc:70] List.len lines = 52
[2020/01.roc:74] List.len numbers = 52

#[no_mangle]
pub extern "C" fn roc_fx_stdinBytes() -> RocResult<RocList<u8>, ()> {
    let stdin = std::io::stdin();
    let mut buffer: [u8; 256] = [0; 256];

    match stdin.lock().read(&mut buffer) {
        Ok(bytes_read) => RocResult::ok(RocList::from(&buffer[0..bytes_read])),
        Err(_) => RocResult::ok(RocList::from(([]).as_slice())),
    }
}

#[no_mangle]
pub extern "C" fn roc_fx_stdinBytes() -> RocResult<RocList<u8>, ()> {
    const BUF_SIZE: usize = 16_384; // 16 KiB = 16 * 1024 = 16,384 bytes
    let stdin = std::io::stdin();
    let mut buffer: [u8; BUF_SIZE] = [0; BUF_SIZE];

    match stdin.lock().read(&mut buffer) {
        Ok(bytes_read) => RocResult::ok(RocList::from(&buffer[0..bytes_read])),
        Err(_) => RocResult::ok(RocList::from(([]).as_slice())),
    }
}

InternalIOErr : {
    tag : [
        BrokenPipe,
        WouldBlock,
        WriteZero,
        Unsupported,
        Interrupted,
        OutOfMemory,
        UnexpectedEof,
        InvalidInput,
        Other,
    ],
    msg : Str,
}

impl From<std::io::Error> for InternalIOErr { ... }

#[non_exhaustive]
pub enum ErrorKind {
    NotFound, // YES
    PermissionDenied, // YES
    ConnectionRefused, // OTHER -- uncommon server related
    ConnectionReset, // OTHER -- uncommon server related
    HostUnreachable, // NO - experimental
    NetworkUnreachable, // NO - experimental
    ConnectionAborted, // OTHER -- uncommon
    NotConnected, // OTHER -- uncommon
    AddrInUse, // OTHER -- uncommon
    AddrNotAvailable, // OTHER -- uncommon
    NetworkDown,  // NO - experimental
    BrokenPipe, // YES - pipe was closed
    AlreadyExists, // YES
    WouldBlock, // OTHER -- async not used in basic-cli
    NotADirectory,  // NO - experimental
    IsADirectory,  // NO - experimental
    DirectoryNotEmpty,  // NO - experimental
    ReadOnlyFilesystem,  // NO - experimental
    FilesystemLoop,  // NO - experimental
    StaleNetworkFileHandle,  // NO - experimental
    InvalidInput,  // NO -- parameter was incorrect, unlikely to be hit
    InvalidData, // NO -- operation parameters were valid, however the error was caused by malformed input data, unlikely to be hit
    TimedOut, // YES -- operation’s timeout expired, causing it to be canceled
    WriteZero, // OTHER -- uncommon
    StorageFull, // NO - experimental
    NotSeekable, // NO - experimental
    FilesystemQuotaExceeded, // NO - experimental
    FileTooLarge, // NO - experimental
    ResourceBusy, // NO - experimental
    ExecutableFileBusy, // NO - experimental
    Deadlock, // NO - experimental
    CrossesDevices, // NO - experimental
    TooManyLinks, // NO - experimental
    InvalidFilename, // NO - experimental
    ArgumentListTooLong, // NO - experimental
    Interrupted, // YES - Interrupted operations can typically be retried
    Unsupported, // YES - operation is unsupported on this platform
    UnexpectedEof, // OTHER - unlikely to be hit
    OutOfMemory, // YES
    Other, // OTHER -- catch all
}

RocIOError [
    NotFound, // YES
    PermissionDenied, // YES
    BrokenPipe, // YES - pipe was closed
    AlreadyExists, // YES
    TimedOut, // YES -- operation’s timeout expired, causing it to be canceled
    Interrupted, // YES - Interrupted operations can typically be retried
    Unsupported, // YES - operation is unsupported on this platform
    OutOfMemory, // YES
    ++ OTHER Str for everything else.
]

#[no_mangle]
pub extern "C" fn roc_fx_stdinLine() -> RocResult<RocStr, glue::IOErr> {
    let stdin = std::io::stdin();

    match stdin.lock().lines().next() {
        None => RocResult::err(RocStr::from("EOF")),
        Some(Ok(str)) => RocResult::ok(RocStr::from(str.as_str())),
        Some(Err(io_err)) => RocResult::err(io_err.into()),
    }
}

#[no_mangle]
pub extern "C" fn roc_fx_stdinLine() -> RocResult<RocStr, glue::IOErr> {
    let stdin = std::io::stdin();

    match stdin.lock().lines().next() {
        None => RocResult::ok("\x04".into()),
        Some(Ok(str)) => RocResult::ok(str.as_str().into()),
        Some(Err(io_err)) => RocResult::err(io_err.into()),
    }
}

when Stdin.line! {} is

    # End of Transmission (EOT) / File (EOF)
    Ok str if str == "\x04" ->
        try Stdout.line! (echo "Received end of input.")
        Ok {}

    Ok str ->
        try Stdout.line! (echo str)
        tick! {}

    Err (StdinErr err) ->
        try Stdout.line! (echo "Unable to read input $(Inspect.toStr err)")
        Ok {}

line! : {} => Result Str [EndOfFile, StdinErr Err]
bytes! : {} => Result (List U8) [StdinErr Err]
readToEnd! : {} => Result (List U8) [StdinErr Err]