etch

-module(examples@events).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/examples/events.gleam").
-export([main/0]).

-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(false).

-file("src/examples/events.gleam", 147).
?DOC(false).
-spec key_event_state_to_string(etch@event:key_event_state()) -> binary().
key_event_state_to_string(Key_event_state) ->
    Capslock = case erlang:element(3, Key_event_state) of
        true ->
            <<"Capslock "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    Keypad = case erlang:element(2, Key_event_state) of
        true ->
            <<"Keypad "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    Numlock = case erlang:element(4, Key_event_state) of
        true ->
            <<"Numlock "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    <<<<Capslock/binary, Keypad/binary>>/binary, Numlock/binary>>.

-file("src/examples/events.gleam", 163).
?DOC(false).
-spec key_event_kind_to_string(etch@event:key_event_kind()) -> binary().
key_event_kind_to_string(Key_event_kind) ->
    case Key_event_kind of
        press ->
            <<"Press"/utf8>>;

        release ->
            <<"Release"/utf8>>;

        repeat ->
            <<"Repeat"/utf8>>
    end.

-file("src/examples/events.gleam", 171).
?DOC(false).
-spec modifiers_to_string(etch@event:modifiers()) -> binary().
modifiers_to_string(Modifiers) ->
    Shift = case erlang:element(2, Modifiers) of
        true ->
            <<"Shift "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    Control = case erlang:element(4, Modifiers) of
        true ->
            <<"Control "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    Alt = case erlang:element(3, Modifiers) of
        true ->
            <<"Alt "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    <<<<Shift/binary, Control/binary>>/binary, Alt/binary>>.

-file("src/examples/events.gleam", 187).
?DOC(false).
-spec flags_to_string(list(etch@event:keyboard_enhancement_flag()), binary()) -> binary().
flags_to_string(L, Acc) ->
    case L of
        [] ->
            Acc;

        [F | Rest] ->
            F@1 = case F of
                disambiguate_escape_code ->
                    <<"DisambiguateEscapeCode"/utf8>>;

                report_all_keys_as_escape_code ->
                    <<"ReportAllKeysAsEscapeCode"/utf8>>;

                report_alternate_keys ->
                    <<"ReportAlternateKeys"/utf8>>;

                report_associated_text ->
                    <<"ReportAssociatedText"/utf8>>;

                report_event_types ->
                    <<"ReportEventTypes"/utf8>>
            end,
            Acc@1 = <<<<Acc/binary, F@1/binary>>/binary, " "/utf8>>,
            flags_to_string(Rest, Acc@1)
    end.

-file("src/examples/events.gleam", 220).
?DOC(false).
-spec button_to_string(etch@event:mouse_button()) -> binary().
button_to_string(Button) ->
    case Button of
        left ->
            <<"Left Mouse Button"/utf8>>;

        right ->
            <<"Right Mouse Button"/utf8>>;

        middle ->
            <<"Middle Mouse Button"/utf8>>
    end.

-file("src/examples/events.gleam", 207).
?DOC(false).
-spec mouse_event_kind_to_string(etch@event:mouse_event_kind()) -> binary().
mouse_event_kind_to_string(Kind) ->
    case Kind of
        {down, Button} ->
            <<"Pressed "/utf8, (button_to_string(Button))/binary>>;

        {up, Button@1} ->
            <<"Released "/utf8, (button_to_string(Button@1))/binary>>;

        {drag, Button@2} ->
            <<"Drag "/utf8, (button_to_string(Button@2))/binary>>;

        moved ->
            <<"Moved"/utf8>>;

        scroll_down ->
            <<"ScrollDown"/utf8>>;

        scroll_up ->
            <<"ScrollUp"/utf8>>;

        scroll_left ->
            <<"ScrollLeft"/utf8>>;

        scroll_right ->
            <<"ScrollRight"/utf8>>
    end.

-file("src/examples/events.gleam", 38).
?DOC(false).
-spec handle_input() -> nil.
handle_input() ->
    case event_ffi:read() of
        {some, {ok, {mouse, M}}} ->
            etch@stdout:execute(
                [{move_to, 0, 0},
                    {clear, from_cursor_down},
                    {println, <<"Press Q to exit"/utf8>>},
                    {println, <<"Press R to get current cursor position"/utf8>>},
                    {println,
                        <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                    {println, <<"Got mouse event"/utf8>>},
                    {println,
                        <<"Kind: "/utf8,
                            (mouse_event_kind_to_string(erlang:element(2, M)))/binary>>},
                    {println,
                        <<"Row: "/utf8,
                            (erlang:integer_to_binary(erlang:element(4, M)))/binary>>},
                    {println,
                        <<"Column: "/utf8,
                            (erlang:integer_to_binary(erlang:element(3, M)))/binary>>},
                    {println,
                        <<"Modifiers: "/utf8,
                            (modifiers_to_string(erlang:element(5, M)))/binary>>}]
            );

        {some, {ok, {resize, C, R}}} ->
            etch@stdout:execute(
                [{move_to, 0, 0},
                    {clear, from_cursor_down},
                    {println, <<"Press Q to exit"/utf8>>},
                    {println, <<"Press R to get current cursor position"/utf8>>},
                    {println,
                        <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                    {println, <<"Window resized. Current size: "/utf8>>},
                    {println,
                        <<"Columns: "/utf8,
                            (erlang:integer_to_binary(C))/binary>>},
                    {println,
                        <<"Rows: "/utf8, (erlang:integer_to_binary(R))/binary>>}]
            );

        {some, {ok, focus_gained}} ->
            etch@stdout:execute(
                [{move_to, 0, 0},
                    {clear, from_cursor_down},
                    {println, <<"Press Q to exit"/utf8>>},
                    {println, <<"Press R to get current cursor position"/utf8>>},
                    {println,
                        <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                    {println, <<"Focus gained."/utf8>>}]
            );

        {some, {ok, focus_lost}} ->
            etch@stdout:execute(
                [{move_to, 0, 0},
                    {clear, from_cursor_down},
                    {println, <<"Press Q to exit"/utf8>>},
                    {println, <<"Press R to get current cursor position"/utf8>>},
                    {println,
                        <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                    {println, <<"Focus lost."/utf8>>}]
            );

        {some, {ok, {key, S}}} ->
            case erlang:element(2, S) of
                {char, <<"Q"/utf8>>} ->
                    erlang:halt(0);

                {char, <<"R"/utf8>>} when erlang:element(4, S) =:= press ->
                    case etch@event:get_cursor_position() of
                        {ok, {X, Y}} ->
                            X@1 = erlang:integer_to_binary(X),
                            Y@1 = erlang:integer_to_binary(Y),
                            etch@stdout:execute(
                                [{println,
                                        <<<<<<"Cursor position:"/utf8,
                                                    X@1/binary>>/binary,
                                                ","/utf8>>/binary,
                                            Y@1/binary>>}]
                            );

                        {error, {failed_to_parse_event, E}} ->
                            etch@stdout:execute([{println, E}])
                    end,
                    nil;

                {char, <<"R"/utf8>>} ->
                    nil;

                {char, <<"F"/utf8>>} ->
                    case etch@event:get_keyboard_enhancement_flags() of
                        {ok, F} ->
                            etch@stdout:execute(
                                [{move_to, 0, 0},
                                    {clear, from_cursor_down},
                                    {println, <<"Press Q to exit"/utf8>>},
                                    {println,
                                        <<"Press R to get current cursor position"/utf8>>},
                                    {println,
                                        <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                                    {println,
                                        <<"Flags: "/utf8,
                                            (flags_to_string(F, <<""/utf8>>))/binary>>}]
                            );

                        {error, {failed_to_parse_event, E@1}} ->
                            etch@stdout:execute([{println, E@1}])
                    end;

                _ ->
                    etch@stdout:execute(
                        [{move_to, 0, 0},
                            {clear, from_cursor_down},
                            {println, <<"Press Q to exit"/utf8>>},
                            {println,
                                <<"Press R to get current cursor position"/utf8>>},
                            {println,
                                <<"Press F to get keyboard enhancement flags\n"/utf8>>},
                            {println,
                                <<<<"Got key event: \""/utf8,
                                        (etch@event:to_string(
                                            erlang:element(2, S)
                                        ))/binary>>/binary,
                                    "\""/utf8>>},
                            {println,
                                <<"Modifiers: "/utf8,
                                    (modifiers_to_string(erlang:element(3, S)))/binary>>},
                            {println,
                                <<"Kind: "/utf8,
                                    (key_event_kind_to_string(
                                        erlang:element(4, S)
                                    ))/binary>>},
                            {println,
                                <<"State: "/utf8,
                                    (key_event_state_to_string(
                                        erlang:element(5, S)
                                    ))/binary>>},
                            {println,
                                <<"Text: "/utf8, (erlang:element(6, S))/binary>>}]
                    ),
                    nil
            end;

        {some, {error, _}} ->
            nil;

        none ->
            nil
    end.

-file("src/examples/events.gleam", 33).
?DOC(false).
-spec loop() -> any().
loop() ->
    handle_input(),
    loop().

-file("src/examples/events.gleam", 14).
?DOC(false).
-spec main() -> any().
main() ->
    etch@stdout:execute(
        [enable_mouse_capture,
            enter_raw,
            {clear, all},
            {set_cursor_style, steady_bar},
            enable_focus_change,
            {push_keyboard_enhancement_flags,
                [disambiguate_escape_code,
                    report_alternate_keys,
                    report_event_types,
                    report_all_keys_as_escape_code,
                    report_associated_text]}]
    ),
    etch@event:init_event_server(),
    loop().