-module(spectator@internal@components@ets_table_live).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/spectator/internal/components/ets_table_live.gleam").
-export([app/0]).
-export_type([model/0, msg/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).

-type model() :: {model,
        gleam@option:option(gleam@erlang@atom:atom_()),
        list({binary(), binary()}),
        gleam@option:option(gleam@erlang@process:subject(msg())),
        integer(),
        gleam@option:option(spectator@internal@api:table()),
        gleam@option:option(spectator@internal@api:table_data()),
        gleam@option:option(integer()),
        spectator@internal@api:sort_direction()}.

-opaque msg() :: refresh |
    {created_subject, gleam@erlang@process:subject(msg())} |
    {heading_clicked, gleam@option:option(integer())}.

-file("src/spectator/internal/components/ets_table_live.gleam", 40).
?DOC(false).
-spec get_ets_table_info_from_list(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@atom:atom_()
) -> {ok, spectator@internal@api:table()} |
    {error, spectator@internal@api:erlang_error()}.
get_ets_table_info_from_list(Node, Table_name) ->
    gleam@result:'try'(
        spectator_ffi:list_ets_tables(Node),
        fun(Tables) ->
            _pipe = gleam@list:find(
                Tables,
                fun(T) -> erlang:element(3, T) =:= Table_name end
            ),
            gleam@result:replace_error(_pipe, returned_undefined_error)
        end
    ).

-file("src/spectator/internal/components/ets_table_live.gleam", 46).
?DOC(false).
-spec get_initial_data(list({binary(), binary()})) -> {ok, model()} |
    {error, spectator@internal@api:erlang_error()}.
get_initial_data(Params) ->
    Node = spectator@internal@api:node_from_params(Params),
    gleam@result:'try'(
        begin
            _pipe = spectator@internal@common:get_param(
                Params,
                <<"table_name"/utf8>>
            ),
            gleam@result:replace_error(_pipe, returned_undefined_error)
        end,
        fun(Table_name) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = gleam_erlang_ffi:atom_from_string(Table_name),
                    gleam@result:replace_error(
                        _pipe@1,
                        returned_undefined_error
                    )
                end,
                fun(Table_atom) ->
                    gleam@result:'try'(
                        gleam@result:lazy_or(
                            spectator_ffi:get_ets_table_info(Node, Table_atom),
                            fun() ->
                                get_ets_table_info_from_list(Node, Table_atom)
                            end
                        ),
                        fun(Table) ->
                            Refresh_interval = spectator@internal@common:get_refresh_interval(
                                Params
                            ),
                            Table_data = begin
                                _pipe@2 = spectator@internal@api:get_ets_data(
                                    Node,
                                    Table
                                ),
                                gleam@option:from_result(_pipe@2)
                            end,
                            {ok,
                                {model,
                                    Node,
                                    spectator@internal@common:sanitize_params(
                                        Params
                                    ),
                                    none,
                                    Refresh_interval,
                                    {some, Table},
                                    Table_data,
                                    none,
                                    descending}}
                        end
                    )
                end
            )
        end
    ).

-file("src/spectator/internal/components/ets_table_live.gleam", 79).
?DOC(false).
-spec init(list({binary(), binary()})) -> {model(), lustre@effect:effect(msg())}.
init(Params) ->
    case get_initial_data(Params) of
        {ok, Model} ->
            {Model,
                spectator@internal@common:emit_after(
                    erlang:element(5, Model),
                    refresh,
                    none,
                    fun(Field@0) -> {created_subject, Field@0} end
                )};

        {error, _} ->
            {{model, none, [], none, 1000, none, none, none, descending},
                lustre@effect:none()}
    end.

-file("src/spectator/internal/components/ets_table_live.gleam", 109).
?DOC(false).
-spec do_refresh(model()) -> model().
do_refresh(Model) ->
    case erlang:element(6, Model) of
        {some, T} ->
            case {spectator@internal@api:get_ets_data(
                    erlang:element(2, Model),
                    T
                ),
                erlang:element(8, Model)} of
                {{ok, Data}, {some, Sort_column_index}} ->
                    Sorted = spectator@internal@api:sort_table_data(
                        Data,
                        Sort_column_index,
                        erlang:element(9, Model)
                    ),
                    {model,
                        erlang:element(2, Model),
                        erlang:element(3, Model),
                        erlang:element(4, Model),
                        erlang:element(5, Model),
                        erlang:element(6, Model),
                        {some, Sorted},
                        erlang:element(8, Model),
                        erlang:element(9, Model)};

                {{ok, Data@1}, none} ->
                    {model,
                        erlang:element(2, Model),
                        erlang:element(3, Model),
                        erlang:element(4, Model),
                        erlang:element(5, Model),
                        erlang:element(6, Model),
                        {some, Data@1},
                        erlang:element(8, Model),
                        erlang:element(9, Model)};

                {{error, _}, _} ->
                    {model, none, [], none, 1000, none, none, none, descending}
            end;

        _ ->
            Model
    end.

-file("src/spectator/internal/components/ets_table_live.gleam", 138).
?DOC(false).
-spec update(model(), msg()) -> {model(), lustre@effect:effect(msg())}.
update(Model, Msg) ->
    case Msg of
        refresh ->
            {do_refresh(Model),
                spectator@internal@common:emit_after(
                    erlang:element(5, Model),
                    refresh,
                    erlang:element(4, Model),
                    fun(Field@0) -> {created_subject, Field@0} end
                )};

        {created_subject, Subject} ->
            {{model,
                    erlang:element(2, Model),
                    erlang:element(3, Model),
                    {some, Subject},
                    erlang:element(5, Model),
                    erlang:element(6, Model),
                    erlang:element(7, Model),
                    erlang:element(8, Model),
                    erlang:element(9, Model)},
                lustre@effect:none()};

        {heading_clicked, Column} ->
            case Column of
                _ when Column =:= erlang:element(8, Model) ->
                    {begin
                            _pipe = {model,
                                erlang:element(2, Model),
                                erlang:element(3, Model),
                                erlang:element(4, Model),
                                erlang:element(5, Model),
                                erlang:element(6, Model),
                                erlang:element(7, Model),
                                erlang:element(8, Model),
                                spectator@internal@api:invert_sort_direction(
                                    erlang:element(9, Model)
                                )},
                            do_refresh(_pipe)
                        end,
                        lustre@effect:none()};

                C ->
                    {begin
                            _pipe@1 = {model,
                                erlang:element(2, Model),
                                erlang:element(3, Model),
                                erlang:element(4, Model),
                                erlang:element(5, Model),
                                erlang:element(6, Model),
                                erlang:element(7, Model),
                                C,
                                erlang:element(9, Model)},
                            do_refresh(_pipe@1)
                        end,
                        lustre@effect:none()}
            end
    end.

-file("src/spectator/internal/components/ets_table_live.gleam", 183).
?DOC(false).
-spec render_table_data(
    model(),
    spectator@internal@api:table(),
    spectator@internal@api:table_data()
) -> lustre@vdom@vnode:element(msg()).
render_table_data(Model, Table, Data) ->
    case erlang:element(3, Data) =:= 0 of
        true ->
            lustre@element@html:'div'(
                [lustre@attribute:class(<<"component-error"/utf8>>)],
                [lustre@element@html:text(<<"No data in table "/utf8>>),
                    spectator@internal@views@display:atom(
                        erlang:element(3, Table)
                    )]
            );

        false ->
            lustre@element@html:table(
                [lustre@attribute:class(<<"ets-data"/utf8>>)],
                [lustre@element@html:thead(
                        [],
                        [lustre@element@html:tr(
                                [],
                                begin
                                    _pipe = gleam@int:range(
                                        0,
                                        erlang:element(3, Data),
                                        [],
                                        fun(Acc, I) -> [I | Acc] end
                                    ),
                                    _pipe@1 = lists:reverse(_pipe),
                                    gleam@list:map(
                                        _pipe@1,
                                        fun(I@1) ->
                                            spectator@internal@views@table:heading(
                                                erlang:integer_to_binary(I@1),
                                                erlang:integer_to_binary(I@1),
                                                {some, I@1},
                                                erlang:element(8, Model),
                                                erlang:element(9, Model),
                                                fun(Field@0) -> {heading_clicked, Field@0} end,
                                                false
                                            )
                                        end
                                    )
                                end
                            )]
                    ),
                    lustre@element@html:tbody(
                        [],
                        spectator@internal@views@table:map_rows(
                            erlang:element(2, Data),
                            fun(Row) ->
                                lustre@element@html:tr(
                                    [lustre@attribute:class(<<"ets-row"/utf8>>)],
                                    gleam@list:map(
                                        Row,
                                        fun(Cell) ->
                                            lustre@element@html:td(
                                                [],
                                                [spectator@internal@views@display:inspect(
                                                        Cell
                                                    )]
                                            )
                                        end
                                    )
                                )
                            end
                        )
                    )]
            )
    end.

-file("src/spectator/internal/components/ets_table_live.gleam", 223).
?DOC(false).
-spec render_not_found() -> lustre@vdom@vnode:element(any()).
render_not_found() ->
    lustre@element@html:'div'(
        [lustre@attribute:class(<<"component-error"/utf8>>)],
        [lustre@element@html:text(
                <<"The referenced table could not be loaded."/utf8>>
            )]
    ).

-file("src/spectator/internal/components/ets_table_live.gleam", 176).
?DOC(false).
-spec view(model()) -> lustre@vdom@vnode:element(msg()).
view(Model) ->
    case {erlang:element(6, Model), erlang:element(7, Model)} of
        {{some, Table}, {some, Data}} ->
            render_table_data(Model, Table, Data);

        {_, _} ->
            render_not_found()
    end.

-file("src/spectator/internal/components/ets_table_live.gleam", 19).
?DOC(false).
-spec app() -> lustre@runtime@app:app(list({binary(), binary()}), model(), msg()).
app() ->
    lustre:application(fun init/1, fun update/2, fun view/1).