telega

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

-export([new/1, hear/1, to_markup/1, one_time/1, persistent/1, resized/1, placeholder/2, selected/1, button/1, new_inline/1, to_inline_markup/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]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(" This module contains the keyboard constructors and useful utilities to work with keyboards\n").

-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(APCG) :: {keyboard_callback_data,
        binary(),
        fun((APCG) -> binary()),
        fun((binary()) -> APCG),
        binary()}.

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

-file("src/telega/keyboard.gleam", 30).
?DOC(" Create a new keyboard\n").
-spec new(list(list(telega@model:keyboard_button()))) -> keyboard().
new(Buttons) ->
    {keyboard, Buttons, none, none, none, none, none}.

-file("src/telega/keyboard.gleam", 41).
-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}.

-file("src/telega/keyboard.gleam", 48).
?DOC(" Build a reply markup for `Message` from a keyboard\n").
-spec to_markup(keyboard()) -> telega@model:send_message_reply_markup_parameters().
to_markup(Keyboard) ->
    {send_message_reply_reply_keyboard_markup_parameters,
        {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)}}.

-file("src/telega/keyboard.gleam", 60).
?DOC(" Make the keyboard one-time\n").
-spec one_time(keyboard()) -> keyboard().
one_time(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        {some, true},
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 65).
?DOC(" Make the keyboard persistent\n").
-spec persistent(keyboard()) -> keyboard().
persistent(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        {some, true},
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 70).
?DOC(" Make the keyboard resizable\n").
-spec resized(keyboard()) -> keyboard().
resized(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        {some, true},
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 75).
?DOC(" Set the placeholder for the input field\n").
-spec placeholder(keyboard(), binary()) -> keyboard().
placeholder(Keyboard, Text) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        {some, Text},
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 81).
?DOC(
    " Make the keyboard selective.\n"
    " Use this parameter if you want to show the keyboard to specific users only.\n"
).
-spec selected(keyboard()) -> keyboard().
selected(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        {some, true}}.

-file("src/telega/keyboard.gleam", 86).
?DOC(" Create a new keyboard button\n").
-spec button(binary()) -> telega@model:keyboard_button().
button(Text) ->
    {keyboard_button, Text, none, none, none, none, none, none}.

-file("src/telega/keyboard.gleam", 105).
?DOC(" Create a new inline keyboard\n").
-spec new_inline(list(list(telega@model:inline_keyboard_button()))) -> inline_keyboard().
new_inline(Buttons) ->
    {inline_keyboard, Buttons}.

-file("src/telega/keyboard.gleam", 110).
?DOC(" Build a reply markup for `Message` from an inline keyboard\n").
-spec to_inline_markup(inline_keyboard()) -> telega@model:send_message_reply_markup_parameters().
to_inline_markup(Keyboard) ->
    {send_message_reply_inline_keyboard_markup_parameters,
        {inline_keyboard_markup, erlang:element(2, Keyboard)}}.

-file("src/telega/keyboard.gleam", 117).
?DOC(" Create a new inline button\n").
-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(4, Callback_data)},
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/telega/keyboard.gleam", 136).
-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@regexp: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 => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"telega/keyboard"/utf8>>,
                        function => <<"filter_inline_keyboard_query"/utf8>>,
                        line => 147})
    end,
    {callback_query_filter, Re}.

-file("src/telega/keyboard.gleam", 173).
?DOC(" Create a new callback data for inline keyboard buttons\n").
-spec new_callback_data(
    binary(),
    fun((APCQ) -> binary()),
    fun((binary()) -> APCQ)
) -> keyboard_callback_data(APCQ).
new_callback_data(Id, Serialize, Deserialize) ->
    {keyboard_callback_data, Id, Serialize, Deserialize, <<":"/utf8>>}.

-file("src/telega/keyboard.gleam", 182).
?DOC(" Change the delimiter for the callback data, usefull if you need to use `:` in the id\n").
-spec set_callback_data_delimiter(keyboard_callback_data(APCS), binary()) -> keyboard_callback_data(APCS).
set_callback_data_delimiter(Data, Delimiter) ->
    _record = Data,
    {keyboard_callback_data,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Delimiter}.

-file("src/telega/keyboard.gleam", 190).
?DOC(" Pack callback data into a callback\n").
-spec pack_callback(keyboard_callback_data(APCV), APCV) -> keyboard_callback(APCV).
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,
        Data,
        erlang:element(2, Callback_data),
        Payload,
        Callback_data}.

-file("src/telega/keyboard.gleam", 201).
?DOC(" Unpack payload into a callback\n").
-spec unpack_callback(binary(), keyboard_callback_data(APCY)) -> {ok,
        keyboard_callback(APCY)} |
    {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,
                    (erlang:element(4, Callback_data))(Data),
                    Id,
                    Payload,
                    Callback_data}}
        end
    ).