chrobot

-module(protocol@io).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([encode__stream_handle/1, decode__stream_handle/1, decode__read_response/1, decode__resolve_blob_response/1, close/2, read/4, resolve_blob/2]).
-export_type([stream_handle/0, read_response/0, resolve_blob_response/0]).

-type stream_handle() :: {stream_handle, binary()}.

-type read_response() :: {read_response,
        gleam@option:option(boolean()),
        binary(),
        boolean()}.

-type resolve_blob_response() :: {resolve_blob_response, binary()}.

-spec encode__stream_handle(stream_handle()) -> gleam@json:json().
encode__stream_handle(Value__) ->
    case Value__ of
        {stream_handle, Inner_value__} ->
            gleam@json:string(Inner_value__)
    end.

-spec decode__stream_handle(gleam@dynamic:dynamic_()) -> {ok, stream_handle()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__stream_handle(Value__) ->
    _pipe = Value__,
    (gleam@dynamic:decode1(
        fun(Field@0) -> {stream_handle, Field@0} end,
        fun gleam@dynamic:string/1
    ))(_pipe).

-spec decode__read_response(gleam@dynamic:dynamic_()) -> {ok, read_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__read_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:optional_field(
            <<"base64Encoded"/utf8>>,
            fun gleam@dynamic:bool/1
        ))(Value__),
        fun(Base64_encoded) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"data"/utf8>>,
                    fun gleam@dynamic:string/1
                ))(Value__),
                fun(Data) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"eof"/utf8>>,
                            fun gleam@dynamic:bool/1
                        ))(Value__),
                        fun(Eof) ->
                            {ok, {read_response, Base64_encoded, Data, Eof}}
                        end
                    )
                end
            )
        end
    ).

-spec decode__resolve_blob_response(gleam@dynamic:dynamic_()) -> {ok,
        resolve_blob_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__resolve_blob_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"uuid"/utf8>>, fun gleam@dynamic:string/1))(
            Value__
        ),
        fun(Uuid) -> {ok, {resolve_blob_response, Uuid}} end
    ).

-spec close(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ALUE),
    stream_handle()
) -> ALUE.
close(Callback__, Handle) ->
    Callback__(
        <<"IO.close"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"handle"/utf8>>, encode__stream_handle(Handle)}]
            )}
    ).

-spec read(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    stream_handle(),
    gleam@option:option(integer()),
    gleam@option:option(integer())
) -> {ok, read_response()} | {error, chrome:request_error()}.
read(Callback__, Handle, Offset, Size) ->
    gleam@result:'try'(
        Callback__(
            <<"IO.read"/utf8>>,
            {some,
                gleam@json:object(
                    begin
                        _pipe = [{<<"handle"/utf8>>,
                                encode__stream_handle(Handle)}],
                        _pipe@1 = chrobot@internal@utils:add_optional(
                            _pipe,
                            Offset,
                            fun(Inner_value__) ->
                                {<<"offset"/utf8>>,
                                    gleam@json:int(Inner_value__)}
                            end
                        ),
                        chrobot@internal@utils:add_optional(
                            _pipe@1,
                            Size,
                            fun(Inner_value__@1) ->
                                {<<"size"/utf8>>,
                                    gleam@json:int(Inner_value__@1)}
                            end
                        )
                    end
                )}
        ),
        fun(Result__) -> _pipe@2 = decode__read_response(Result__),
            gleam@result:replace_error(_pipe@2, protocol_error) end
    ).

-spec resolve_blob(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    protocol@runtime:remote_object_id()
) -> {ok, resolve_blob_response()} | {error, chrome:request_error()}.
resolve_blob(Callback__, Object_id) ->
    gleam@result:'try'(
        Callback__(
            <<"IO.resolveBlob"/utf8>>,
            {some,
                gleam@json:object(
                    [{<<"objectId"/utf8>>,
                            protocol@runtime:encode__remote_object_id(Object_id)}]
                )}
        ),
        fun(Result__) -> _pipe = decode__resolve_blob_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error) end
    ).