clamav_client

-module(common@tcp).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([connect/2, send_bytes/4, receive_bytes/3]).

-file("/home/runner/work/gleam-clamav/gleam-clamav/src/common/tcp.gleam", 6).
-spec connect(
    client_options:clam_av_client_options(),
    fun((mug:socket()) -> {ok, GME} | {error, mug:error()})
) -> {ok, GME} | {error, mug:error()}.
connect(Options, Callback) ->
    Socket = begin
        _pipe = mug:new(erlang:element(2, Options), erlang:element(3, Options)),
        _pipe@1 = mug:timeout(_pipe, erlang:element(4, Options)),
        mug:connect(_pipe@1)
    end,
    case Socket of
        {ok, Socket@1} ->
            Callback(Socket@1);

        {error, Error} ->
            (erlang:element(2, erlang:element(6, Options)))(
                <<"Failed to connect to ClamAV server: "/utf8,
                    (begin
                        _pipe@2 = Error,
                        gleam@string:inspect(_pipe@2)
                    end)/binary>>
            ),
            {error, Error}
    end.

-file("/home/runner/work/gleam-clamav/gleam-clamav/src/common/tcp.gleam", 26).
-spec send_bytes(
    mug:socket(),
    bitstring(),
    client_options:clam_av_client_options(),
    fun(() -> {ok, GMK} | {error, mug:error()})
) -> {ok, GMK} | {error, mug:error()}.
send_bytes(Socket, Bits, Options, Callback) ->
    case mug:send(Socket, Bits) of
        {ok, _} ->
            Callback();

        {error, Error} ->
            (erlang:element(2, erlang:element(6, Options)))(
                <<"Failed to send byte packet: "/utf8,
                    (begin
                        _pipe = Error,
                        gleam@string:inspect(_pipe)
                    end)/binary>>
            ),
            {error, Error}
    end.

-file("/home/runner/work/gleam-clamav/gleam-clamav/src/common/tcp.gleam", 43).
-spec receive_bytes(
    mug:socket(),
    client_options:clam_av_client_options(),
    fun((bitstring()) -> {ok, GMP} | {error, mug:error()})
) -> {ok, GMP} | {error, mug:error()}.
receive_bytes(Socket, Options, Callback) ->
    case mug:'receive'(Socket, erlang:element(5, Options)) of
        {ok, Bits} ->
            Byte_size = erlang:byte_size(Bits),
            case begin
                _pipe = Bits,
                gleam_stdlib:bit_array_slice(_pipe, 0, Byte_size - 1)
            end of
                {ok, Sliced_bits} ->
                    _pipe@1 = Sliced_bits,
                    Callback(_pipe@1);

                {error, nil} ->
                    {error, einval}
            end;

        {error, Error} ->
            (erlang:element(2, erlang:element(6, Options)))(
                <<"Failed to receive byte packet: "/utf8,
                    (begin
                        _pipe@2 = Error,
                        gleam@string:inspect(_pipe@2)
                    end)/binary>>
            ),
            {error, Error}
    end.