-module(whisper@buffer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/whisper/buffer.gleam").
-export([new_buffer/1, push/2, pop/1]).
-export_type([bounded_buffer/1]).

-opaque bounded_buffer(DXP) :: {bounded_buffer,
        gleam@deque:deque(DXP),
        integer(),
        integer()}.

-file("src/whisper/buffer.gleam", 7).
-spec new_buffer(integer()) -> bounded_buffer(any()).
new_buffer(Capacity) ->
    {bounded_buffer, gleam@deque:new(), Capacity, 0}.

-file("src/whisper/buffer.gleam", 11).
-spec push(bounded_buffer(DXS), DXS) -> bounded_buffer(DXS).
push(Buffer, Message) ->
    New_deque = gleam@deque:push_back(erlang:element(2, Buffer), Message),
    New_size = erlang:element(4, Buffer) + 1,
    case New_size > erlang:element(3, Buffer) of
        true ->
            Remaining@1 = case gleam@deque:pop_front(New_deque) of
                {ok, {_, Remaining}} -> Remaining;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"whisper/buffer"/utf8>>,
                                function => <<"push"/utf8>>,
                                line => 17,
                                value => _assert_fail,
                                start => 472,
                                'end' => 531,
                                pattern_start => 483,
                                pattern_end => 502})
            end,
            {bounded_buffer,
                Remaining@1,
                erlang:element(3, Buffer),
                erlang:element(3, Buffer)};

        false ->
            {bounded_buffer, New_deque, erlang:element(3, Buffer), New_size}
    end.

-file("src/whisper/buffer.gleam", 24).
-spec pop(bounded_buffer(DXV)) -> {{ok, DXV} | {error, nil},
    bounded_buffer(DXV)}.
pop(Buffer) ->
    case gleam@deque:pop_front(erlang:element(2, Buffer)) of
        {ok, {Message, Remaining}} ->
            {{ok, Message},
                {bounded_buffer,
                    Remaining,
                    erlang:element(3, Buffer),
                    erlang:element(4, Buffer) - 1}};

        {error, nil} ->
            {{error, nil}, Buffer}
    end.