-module(nerf@websocket).
-compile([no_auto_import, nowarn_unused_vars]).

-export([send/2, send_builder/2, send_binary/2, send_binary_builder/2, close/1, 'receive'/2, connect/4]).
-export_type([connection/0, frame/0, connect_error/0]).

-opaque connection() :: {connection,
        nerf@gun:stream_reference(),
        nerf@gun:connection_pid()}.

-type frame() :: close | {text, binary()} | {binary, bitstring()}.

-type connect_error() :: {connection_refused,
        integer(),
        list({binary(), binary()})} |
    {connection_failed, gleam@dynamic:dynamic()}.

-spec send(connection(), binary()) -> nil.
send(Conn, Message) ->
    nerf@gun:ws_send(erlang:element(3, Conn), {text, Message}).

-spec send_builder(connection(), gleam@string_builder:string_builder()) -> nil.
send_builder(Conn, Message) ->
    nerf@gun:ws_send(erlang:element(3, Conn), {text_builder, Message}).

-spec send_binary(connection(), bitstring()) -> nil.
send_binary(Conn, Message) ->
    nerf@gun:ws_send(erlang:element(3, Conn), {binary, Message}).

-spec send_binary_builder(connection(), gleam@bit_builder:bit_builder()) -> nil.
send_binary_builder(Conn, Message) ->
    nerf@gun:ws_send(erlang:element(3, Conn), {binary_builder, Message}).

-spec close(connection()) -> nil.
close(Conn) ->
    nerf@gun:ws_send(erlang:element(3, Conn), close).

-spec 'receive'(connection(), integer()) -> {ok, frame()} | {error, nil}.
'receive'(Field@0, Field@1) ->
    nerf_ffi:ws_receive(Field@0, Field@1).

-spec connect(binary(), binary(), integer(), list({binary(), binary()})) -> {ok,
        connection()} |
    {error, connect_error()}.
connect(Hostname, Path, Port, Headers) ->
    gleam@result:'try'(
        begin
            _pipe = nerf@gun:open(Hostname, Port),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {connection_failed, Field@0} end
            )
        end,
        fun(Pid) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = gun:await_up(Pid),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(Field@0) -> {connection_failed, Field@0} end
                    )
                end,
                fun(_) ->
                    Ref = gun:ws_upgrade(Pid, Path, Headers),
                    Conn = {connection, Ref, Pid},
                    gleam@result:'try'(
                        begin
                            _pipe@2 = nerf_ffi:ws_await_upgrade(Conn, 1000),
                            gleam@result:map_error(
                                _pipe@2,
                                fun(Field@0) -> {connection_failed, Field@0} end
                            )
                        end,
                        fun(_) -> {ok, Conn} end
                    )
                end
            )
        end
    ).