-module(telega@keyboard).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/1, hear/1, build/1, one_time/1, persistent/1, resized/1, placeholder/2, selected/1, button/1, new_inline/1, build_inline/1, inline_button/2, filter_inline_keyboard_query/1, new_callback_data/3, set_callback_data_delimiter/2, pack_callback/2, unpack_callback/2]).
-export_type([keyboard/0, inline_keyboard/0, keyboard_callback_data/1, keyboard_callback/1]).

-opaque keyboard() :: {keyboard,
        list(list(telega@model:keyboard_button())),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(binary()),
        gleam@option:option(boolean())}.

-opaque inline_keyboard() :: {inline_keyboard,
        list(list(telega@model:inline_keyboard_button()))}.

-opaque keyboard_callback_data(VEE) :: {keyboard_callback_data,
        binary(),
        fun((VEE) -> binary()),
        fun((binary()) -> VEE),
        binary()}.

-type keyboard_callback(VEF) :: {keyboard_callback,
        binary(),
        binary(),
        VEF,
        keyboard_callback_data(VEF)}.

-spec new(list(list(telega@model:keyboard_button()))) -> keyboard().
new(Buttons) ->
    {keyboard, Buttons, none, none, none, none, none}.

-spec hear(keyboard()) -> telega@bot:hears().
hear(Keyboard) ->
    _pipe = erlang:element(2, Keyboard),
    _pipe@1 = gleam@list:flat_map(
        _pipe,
        fun(Row) ->
            gleam@list:map(Row, fun(Button) -> erlang:element(2, Button) end)
        end
    ),
    {hear_texts, _pipe@1}.

-spec build(keyboard()) -> telega@model:reply_markup().
build(Keyboard) ->
    {reply_keyboard_markup,
        erlang:element(2, Keyboard),
        erlang:element(3, Keyboard),
        erlang:element(4, Keyboard),
        erlang:element(5, Keyboard),
        erlang:element(6, Keyboard),
        erlang:element(7, Keyboard)}.

-spec one_time(keyboard()) -> keyboard().
one_time(Keyboard) ->
    erlang:setelement(5, Keyboard, {some, true}).

-spec persistent(keyboard()) -> keyboard().
persistent(Keyboard) ->
    erlang:setelement(3, Keyboard, {some, true}).

-spec resized(keyboard()) -> keyboard().
resized(Keyboard) ->
    erlang:setelement(4, Keyboard, {some, true}).

-spec placeholder(keyboard(), binary()) -> keyboard().
placeholder(Keyboard, Text) ->
    erlang:setelement(6, Keyboard, {some, Text}).

-spec selected(keyboard()) -> keyboard().
selected(Keyboard) ->
    erlang:setelement(7, Keyboard, {some, true}).

-spec button(binary()) -> telega@model:keyboard_button().
button(Text) ->
    {keyboard_button, Text, none, none, none, none, none, none}.

-spec new_inline(list(list(telega@model:inline_keyboard_button()))) -> inline_keyboard().
new_inline(Buttons) ->
    {inline_keyboard, Buttons}.

-spec build_inline(inline_keyboard()) -> telega@model:reply_markup().
build_inline(Keyboard) ->
    {reply_inline_keyboard_markup, erlang:element(2, Keyboard)}.

-spec inline_button(binary(), keyboard_callback(any())) -> telega@model:inline_keyboard_button().
inline_button(Text, Callback_data) ->
    {inline_keyboard_button,
        Text,
        none,
        {some, erlang:element(3, Callback_data)},
        none,
        none,
        none,
        none,
        none,
        none}.

-spec filter_inline_keyboard_query(inline_keyboard()) -> telega@bot:callback_query_filter().
filter_inline_keyboard_query(Keyboard) ->
    Options = begin
        _pipe = erlang:element(2, Keyboard),
        _pipe@1 = gleam@list:flat_map(
            _pipe,
            fun(Row) ->
                gleam@list:map(
                    Row,
                    fun(Button) -> erlang:element(4, Button) end
                )
            end
        ),
        _pipe@2 = gleam@option:values(_pipe@1),
        gleam@string:join(_pipe@2, <<"|"/utf8>>)
    end,
    _assert_subject = gleam@regex:from_string(
        <<<<"^("/utf8, Options/binary>>/binary, ")$"/utf8>>
    ),
    {ok, Re} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"telega/keyboard"/utf8>>,
                        function => <<"filter_inline_keyboard_query"/utf8>>,
                        line => 144})
    end,
    {callback_query_filter, Re}.

-spec new_callback_data(
    binary(),
    fun((VEM) -> binary()),
    fun((binary()) -> VEM)
) -> keyboard_callback_data(VEM).
new_callback_data(Id, Serilize, Deserialize) ->
    {keyboard_callback_data, Id, Serilize, Deserialize, <<":"/utf8>>}.

-spec set_callback_data_delimiter(keyboard_callback_data(VEO), binary()) -> keyboard_callback_data(VEO).
set_callback_data_delimiter(Data, Delimiter) ->
    erlang:setelement(5, Data, Delimiter).

-spec pack_callback(keyboard_callback_data(VER), VER) -> keyboard_callback(VER).
pack_callback(Callback_data, Data) ->
    Payload = <<<<(erlang:element(2, Callback_data))/binary,
            (erlang:element(5, Callback_data))/binary>>/binary,
        ((erlang:element(3, Callback_data))(Data))/binary>>,
    {keyboard_callback,
        erlang:element(2, Callback_data),
        Payload,
        Data,
        Callback_data}.

-spec unpack_callback(binary(), keyboard_callback_data(VEU)) -> {ok,
        keyboard_callback(VEU)} |
    {error, nil}.
unpack_callback(Payload, Callback_data) ->
    gleam@result:'try'(
        gleam@string:split_once(Payload, erlang:element(5, Callback_data)),
        fun(_use0) ->
            {Id, Data} = _use0,
            {ok,
                {keyboard_callback,
                    Id,
                    Payload,
                    (erlang:element(4, Callback_data))(Data),
                    Callback_data}}
        end
    ).