etch

-module(etch@stdout).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/etch/stdout.gleam").
-export([queue/2, flush/1, execute/1]).
-export_type([queue/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(
    " This module provides a way to queue and flush commands.\n"
    " ```gleam\n"
    " import stdout.{Queue, queue, flush}\n"
    "\n"
    " let q = Queue([])\n"
    " queue(q, [\n"
    "   EnterRaw,\n"
    "   EnterAlternativeScreen,\n"
    "   HideCursor,\n"
    "   Println(\"Hello from Etch\"),\n"
    " ])\n"
    " flush(q)\n"
    " ```\n"
).

-type queue() :: {queue, list(etch@command:command())}.

-file("src/etch/stdout.gleam", 57).
?DOC(
    " Adds [`Commands`](#command.html#Command)\n"
    " to the [`Queue`](stdout.html#Command).\n"
).
-spec queue(queue(), list(etch@command:command())) -> queue().
queue(Queue, Commands) ->
    {queue, lists:append(erlang:element(2, Queue), Commands)}.

-file("src/etch/stdout.gleam", 74).
-spec flush_inner(list(etch@command:command()), gleam@string_tree:string_tree()) -> nil.
flush_inner(Commands, Tree) ->
    case Commands of
        [] ->
            gleam_stdlib:print(
                begin
                    _pipe = Tree,
                    unicode:characters_to_binary(_pipe)
                end
            );

        [{print, Str} | Rest] ->
            flush_inner(
                Rest,
                begin
                    _pipe@1 = Tree,
                    gleam@string_tree:append(_pipe@1, Str)
                end
            );

        [{print_reset, Str@1} | Rest@1] ->
            flush_inner(
                Rest@1,
                gleam@string_tree:append(
                    Tree,
                    <<<<Str@1/binary, "\x{001b}["/utf8>>/binary, "0m"/utf8>>
                )
            );

        [{println, Str@2} | Rest@2] ->
            flush_inner(
                Rest@2,
                gleam@string_tree:append(
                    Tree,
                    <<Str@2/binary, (etch@cursor:move_to_next_line(1))/binary>>
                )
            );

        [{println_reset, Str@3} | Rest@3] ->
            flush_inner(
                Rest@3,
                gleam@string_tree:append(
                    Tree,
                    <<<<<<Str@3/binary,
                                (etch@cursor:move_to_next_line(1))/binary>>/binary,
                            "\x{001b}["/utf8>>/binary,
                        "0m"/utf8>>
                )
            );

        [{move_up, N} | Rest@4] ->
            flush_inner(
                Rest@4,
                gleam@string_tree:append(Tree, etch@cursor:move_up(N))
            );

        [{move_down, N@1} | Rest@5] ->
            flush_inner(
                Rest@5,
                gleam@string_tree:append(Tree, etch@cursor:move_down(N@1))
            );

        [{move_left, N@2} | Rest@6] ->
            flush_inner(
                Rest@6,
                gleam@string_tree:append(Tree, etch@cursor:move_left(N@2))
            );

        [{move_right, N@3} | Rest@7] ->
            flush_inner(
                Rest@7,
                gleam@string_tree:append(Tree, etch@cursor:move_right(N@3))
            );

        [{move_to_next_line, N@4} | Rest@8] ->
            flush_inner(
                Rest@8,
                begin
                    _pipe@2 = Tree,
                    gleam@string_tree:append(
                        _pipe@2,
                        etch@cursor:move_to_next_line(N@4)
                    )
                end
            );

        [{move_to_previous_line, N@5} | Rest@9] ->
            flush_inner(
                Rest@9,
                begin
                    _pipe@3 = Tree,
                    gleam@string_tree:append(
                        _pipe@3,
                        etch@cursor:move_to_previous_line(N@5)
                    )
                end
            );

        [{move_to_column, N@6} | Rest@10] ->
            flush_inner(
                Rest@10,
                begin
                    _pipe@4 = Tree,
                    gleam@string_tree:append(
                        _pipe@4,
                        etch@cursor:move_to_column(N@6)
                    )
                end
            );

        [{move_to_row, N@7} | Rest@11] ->
            flush_inner(
                Rest@11,
                gleam@string_tree:append(Tree, etch@cursor:move_to_row(N@7))
            );

        [{move_to, X, Y} | Rest@12] ->
            flush_inner(
                Rest@12,
                gleam@string_tree:append(Tree, etch@cursor:move_to(X, Y))
            );

        [save_position | Rest@13] ->
            flush_inner(
                Rest@13,
                gleam@string_tree:append(Tree, etch@cursor:save_position())
            );

        [restore_position | Rest@14] ->
            flush_inner(
                Rest@14,
                begin
                    _pipe@5 = Tree,
                    gleam@string_tree:append(
                        _pipe@5,
                        etch@cursor:restore_position()
                    )
                end
            );

        [show_cursor | Rest@15] ->
            flush_inner(
                Rest@15,
                gleam@string_tree:append(Tree, etch@cursor:show())
            );

        [hide_cursor | Rest@16] ->
            flush_inner(
                Rest@16,
                gleam@string_tree:append(Tree, etch@cursor:hide())
            );

        [{set_cursor_style, S} | Rest@17] ->
            flush_inner(
                Rest@17,
                gleam@string_tree:append(Tree, etch@cursor:set_cursor_style(S))
            );

        [{scroll_down, N@8} | Rest@18] ->
            flush_inner(
                Rest@18,
                gleam@string_tree:append(Tree, etch@terminal:scroll_down(N@8))
            );

        [{scroll_up, N@9} | Rest@19] ->
            flush_inner(
                Rest@19,
                gleam@string_tree:append(Tree, etch@terminal:scroll_up(N@9))
            );

        [{clear, T} | Rest@20] ->
            flush_inner(
                Rest@20,
                gleam@string_tree:append(Tree, etch@terminal:clear(T))
            );

        [{set_size, X@1, Y@1} | Rest@21] ->
            flush_inner(
                Rest@21,
                gleam@string_tree:append(Tree, etch@terminal:set_size(X@1, Y@1))
            );

        [{set_title, S@1} | Rest@22] ->
            flush_inner(
                Rest@22,
                gleam@string_tree:append(Tree, etch@terminal:set_title(S@1))
            );

        [enable_line_wrap | Rest@23] ->
            flush_inner(
                Rest@23,
                gleam@string_tree:append(Tree, etch@terminal:enable_line_wrap())
            );

        [disable_line_wrap | Rest@24] ->
            flush_inner(
                Rest@24,
                gleam@string_tree:append(
                    Tree,
                    etch@terminal:disable_line_wrap()
                )
            );

        [enter_raw | Rest@25] ->
            terminal_ffi:enter_raw(),
            flush_inner(Rest@25, Tree);

        [enter_alternate_screen | Rest@26] ->
            flush_inner(
                Rest@26,
                gleam@string_tree:append(
                    Tree,
                    etch@terminal:enter_alternative()
                )
            );

        [leave_alternate_screen | Rest@27] ->
            flush_inner(
                Rest@27,
                gleam@string_tree:append(
                    Tree,
                    etch@terminal:leave_alternative()
                )
            );

        [enable_mouse_capture | Rest@28] ->
            flush_inner(
                Rest@28,
                gleam@string_tree:append(
                    Tree,
                    etch@event:enable_mouse_capture()
                )
            );

        [disable_mouse_capture | Rest@29] ->
            flush_inner(
                Rest@29,
                gleam@string_tree:append(
                    Tree,
                    etch@event:disable_mouse_capture()
                )
            );

        [disable_focus_change | Rest@30] ->
            flush_inner(
                Rest@30,
                gleam@string_tree:append(
                    Tree,
                    etch@event:disable_focus_change()
                )
            );

        [enable_focus_change | Rest@31] ->
            flush_inner(
                Rest@31,
                gleam@string_tree:append(Tree, etch@event:enable_focus_change())
            );

        [{push_keyboard_enhancement_flags, F} | Rest@32] ->
            flush_inner(
                Rest@32,
                gleam@string_tree:append(
                    Tree,
                    etch@event:push_keyboard_enhancement_flags(F)
                )
            );

        [pop_keyboard_enhancement_flags | Rest@33] ->
            flush_inner(
                Rest@33,
                begin
                    _pipe@6 = Tree,
                    gleam@string_tree:append(
                        _pipe@6,
                        etch@event:pop_keyboard_enhancement_flags()
                    )
                end
            );

        [{set_foreground_color, C} | Rest@34] ->
            flush_inner(
                Rest@34,
                gleam@string_tree:append(Tree, etch@style:with(<<""/utf8>>, C))
            );

        [{set_background_color, C@1} | Rest@35] ->
            flush_inner(
                Rest@35,
                gleam@string_tree:append(Tree, etch@style:on(<<""/utf8>>, C@1))
            );

        [{set_foreground_and_background_colors, Fg, Bg} | Rest@36] ->
            flush_inner(
                Rest@36,
                gleam@string_tree:append(
                    Tree,
                    etch@style:with_on(<<""/utf8>>, Fg, Bg)
                )
            );

        [{set_style, S@2} | Rest@37] ->
            flush_inner(
                Rest@37,
                gleam@string_tree:append(Tree, etch@style:set_style(S@2))
            );

        [reset_style | Rest@38] ->
            flush_inner(
                Rest@38,
                gleam@string_tree:append(
                    Tree,
                    etch@style:reset_style(<<""/utf8>>)
                )
            );

        [reset_color | Rest@39] ->
            flush_inner(
                Rest@39,
                gleam@string_tree:append(
                    Tree,
                    etch@style:reset_color(<<""/utf8>>)
                )
            );

        [reset_foreground | Rest@40] ->
            flush_inner(
                Rest@40,
                gleam@string_tree:append(
                    Tree,
                    etch@style:reset_foreground(<<""/utf8>>)
                )
            );

        [reset_background | Rest@41] ->
            flush_inner(
                Rest@41,
                gleam@string_tree:append(
                    Tree,
                    etch@style:reset_background(<<""/utf8>>)
                )
            );

        [reset_attributes | Rest@42] ->
            flush_inner(
                Rest@42,
                gleam@string_tree:append(
                    Tree,
                    etch@style:reset_attributes(<<""/utf8>>)
                )
            );

        [{set_attributes, Attrs} | Rest@43] ->
            flush_inner(
                Rest@43,
                gleam@string_tree:append(
                    Tree,
                    etch@style:attributes(<<""/utf8>>, Attrs)
                )
            )
    end.

-file("src/etch/stdout.gleam", 62).
?DOC(" Flushes the [`Queue`](stdout.html#Command).\n").
-spec flush(queue()) -> queue().
flush(Queue) ->
    Tree = gleam@string_tree:new(),
    flush_inner(erlang:element(2, Queue), Tree),
    {queue, []}.

-file("src/etch/stdout.gleam", 69).
?DOC(" Flushes [`Commands`](#command.html#Command) without queueing them beforehand.\n").
-spec execute(list(etch@command:command())) -> nil.
execute(Commands) ->
    Tree = gleam@string_tree:new(),
    flush_inner(Commands, Tree).