spectator

-module(spectator@internal@components@processes_live).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([app/0]).
-export_type([model/0, msg/0]).

-type model() :: {model,
        gleam@option:option(gleam@erlang@process:subject(msg())),
        list(spectator@internal@api:process_item()),
        spectator@internal@api:info_sort_criteria(),
        spectator@internal@api:sort_direction(),
        gleam@option:option(spectator@internal@api:process_item()),
        gleam@option:option(spectator@internal@api:process_details()),
        gleam@option:option(spectator@internal@api:status()),
        gleam@option:option(gleam@dynamic:dynamic_())}.

-opaque msg() :: refresh |
    {received_otp_details, spectator@internal@api:otp_details()} |
    {created_subject, gleam@erlang@process:subject(msg())} |
    {process_clicked, spectator@internal@api:process_item()} |
    {heading_clicked, spectator@internal@api:info_sort_criteria()} |
    {otp_state_clicked,
        spectator@internal@api:process_item(),
        spectator@internal@api:sys_state()}.

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 37).
-spec emit_after(
    integer(),
    msg(),
    gleam@option:option(gleam@erlang@process:subject(msg()))
) -> lustre@effect:effect(msg()).
emit_after(Delay, Msg, Subject) ->
    case Subject of
        {some, Self} ->
            lustre@effect:from(
                fun(_) ->
                    _ = gleam@erlang@process:send_after(Self, Delay, Msg),
                    nil
                end
            );

        none ->
            lustre@server_component:select(
                fun(Dispatch, Subject@1) ->
                    Selector = begin
                        _pipe = gleam_erlang_ffi:new_selector(),
                        gleam@erlang@process:selecting(
                            _pipe,
                            Subject@1,
                            fun(Msg@1) -> Msg@1 end
                        )
                    end,
                    _ = gleam@erlang@process:send_after(Subject@1, Delay, Msg),
                    Dispatch({created_subject, Subject@1}),
                    Selector
                end
            )
    end.

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 61).
-spec request_otp_details(
    gleam@erlang@process:pid_(),
    gleam@option:option(gleam@erlang@process:subject(msg()))
) -> lustre@effect:effect(msg()).
request_otp_details(Pid, Subject) ->
    case Subject of
        {some, Sub} ->
            lustre@effect:from(
                fun(_) ->
                    spectator@internal@api:request_otp_data(
                        Pid,
                        fun(Details) ->
                            gleam@erlang@process:send(
                                Sub,
                                {received_otp_details, Details}
                            )
                        end
                    ),
                    nil
                end
            );

        none ->
            lustre@effect:none()
    end.

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 108).
-spec do_refresh(model()) -> model().
do_refresh(Model) ->
    Info = spectator@internal@api:get_info_list(),
    Sorted = spectator@internal@api:sort_info_list(
        Info,
        erlang:element(4, Model),
        erlang:element(5, Model)
    ),
    Active_process@1 = case erlang:element(6, Model) of
        none ->
            none;

        {some, Active_process} ->
            case spectator_ffi:get_info(erlang:element(2, Active_process)) of
                {ok, Info@1} ->
                    {some,
                        {process_item,
                            erlang:element(2, Active_process),
                            Info@1}};

                {error, _} ->
                    none
            end
    end,
    Details@1 = case Active_process@1 of
        none ->
            none;

        {some, Ap} ->
            case spectator_ffi:get_details(erlang:element(2, Ap)) of
                {ok, Details} ->
                    {some, Details};

                {error, _} ->
                    none
            end
    end,
    erlang:setelement(
        7,
        erlang:setelement(
            3,
            erlang:setelement(6, Model, Active_process@1),
            Sorted
        ),
        Details@1
    ).

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 135).
-spec update(model(), msg()) -> {model(), lustre@effect:effect(msg())}.
update(Model, Msg) ->
    case Msg of
        refresh ->
            New_model = do_refresh(Model),
            case erlang:element(6, New_model) of
                {some, P} ->
                    {New_model,
                        request_otp_details(
                            erlang:element(2, P),
                            erlang:element(2, Model)
                        )};

                none ->
                    {New_model, lustre@effect:none()}
            end;

        {created_subject, Subject} ->
            {erlang:setelement(2, Model, {some, Subject}), lustre@effect:none()};

        {process_clicked, P@1} ->
            New_model@1 = begin
                _pipe = erlang:setelement(
                    8,
                    erlang:setelement(
                        9,
                        erlang:setelement(6, Model, {some, P@1}),
                        none
                    ),
                    none
                ),
                do_refresh(_pipe)
            end,
            {New_model@1,
                request_otp_details(
                    erlang:element(2, P@1),
                    erlang:element(2, Model)
                )};

        {heading_clicked, Criteria} ->
            case Criteria of
                C when C =:= erlang:element(4, Model) ->
                    New_model@2 = erlang:setelement(
                        5,
                        Model,
                        spectator@internal@api:invert_sort_direction(
                            erlang:element(5, Model)
                        )
                    ),
                    {do_refresh(New_model@2), lustre@effect:none()};

                C@1 ->
                    New_model@3 = erlang:setelement(4, Model, C@1),
                    {do_refresh(New_model@3), lustre@effect:none()}
            end;

        {received_otp_details, Details} ->
            case erlang:element(6, Model) of
                {some, P@2} when erlang:element(2, P@2) =:= erlang:element(
                    2,
                    Details
                ) ->
                    {erlang:setelement(
                            8,
                            erlang:setelement(
                                9,
                                Model,
                                {some, erlang:element(4, Details)}
                            ),
                            {some, erlang:element(3, Details)}
                        ),
                        lustre@effect:none()};

                _ ->
                    {Model, lustre@effect:none()}
            end;

        {otp_state_clicked, P@3, Target_sys_state} ->
            case Target_sys_state of
                suspended ->
                    sys:resume(erlang:element(2, P@3)),
                    {do_refresh(Model),
                        request_otp_details(
                            erlang:element(2, P@3),
                            erlang:element(2, Model)
                        )};

                running ->
                    sys:suspend(erlang:element(2, P@3)),
                    {do_refresh(Model),
                        request_otp_details(
                            erlang:element(2, P@3),
                            erlang:element(2, Model)
                        )}
            end
    end.

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 202).
-spec view(model()) -> lustre@internals@vdom:element(msg()).
view(Model) ->
    spectator@internal@views@process_table:render(
        erlang:element(3, Model),
        fun(Field@0) -> {process_clicked, Field@0} end,
        erlang:element(6, Model),
        erlang:element(7, Model),
        erlang:element(8, Model),
        erlang:element(9, Model),
        erlang:element(4, Model),
        erlang:element(5, Model),
        fun(Field@0) -> {heading_clicked, Field@0} end,
        fun(Field@0, Field@1) -> {otp_state_clicked, Field@0, Field@1} end
    ).

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 77).
-spec init(any()) -> {model(), lustre@effect:effect(msg())}.
init(_) ->
    Info = spectator@internal@api:get_info_list(),
    Default_sort_criteria = reductions,
    Default_sort_direction = descending,
    Sorted = spectator@internal@api:sort_info_list(
        Info,
        Default_sort_criteria,
        descending
    ),
    {{model,
            none,
            Sorted,
            Default_sort_criteria,
            Default_sort_direction,
            none,
            none,
            none,
            none},
        emit_after(500, refresh, none)}.

-file("/Users/jonas/Projects/spectator/src/spectator/internal/components/processes_live.gleam", 15).
-spec app() -> lustre:app(any(), model(), msg()).
app() ->
    lustre:application(fun init/1, fun update/2, fun view/1).