sprocket

-module(test_helpers).
-compile([no_auto_import, nowarn_unused_vars]).

-export([live/1, render_html/1, render_event/3]).
-export_type([event/0]).

-type event() :: click_event.

-spec live(sprocket@element:element()) -> gleam@erlang@process:subject(sprocket@sprocket:message()).
live(View) ->
    sprocket@sprocket:start(none, {some, View}, none).

-spec render_html(gleam@erlang@process:subject(sprocket@sprocket:message())) -> {gleam@erlang@process:subject(sprocket@sprocket:message()),
    binary()}.
render_html(Spkt) ->
    Renderer = sprocket@internal@render@html:renderer(),
    Html = begin
        _pipe = sprocket@sprocket:render(Spkt),
        (erlang:element(2, Renderer))(_pipe)
    end,
    {Spkt, Html}.

-spec render_event(
    gleam@erlang@process:subject(sprocket@sprocket:message()),
    event(),
    binary()
) -> gleam@erlang@process:subject(sprocket@sprocket:message()).
render_event(Spkt, Event, Html_id) ->
    case sprocket@sprocket:get_rendered(Spkt) of
        {some, Rendered} ->
            Found = sprocket@render:find(Rendered, fun(El) -> case El of
                        {rendered_element, _, _, Attrs, _} ->
                            Matching_id_attr = begin
                                _pipe = Attrs,
                                gleam@list:find(_pipe, fun(Attr) -> case Attr of
                                            {rendered_attribute,
                                                <<"id"/utf8>>,
                                                Id} when Id =:= Html_id ->
                                                true;

                                            _ ->
                                                false
                                        end end)
                            end,
                            case Matching_id_attr of
                                {ok, _} ->
                                    true;

                                _ ->
                                    false
                            end;

                        _ ->
                            false
                    end end),
            case Found of
                {ok, {rendered_element, _, _, Attrs@1, _}} ->
                    Event_kind = case Event of
                        click_event ->
                            <<"click"/utf8>>
                    end,
                    Rendered_event_handler = begin
                        _pipe@1 = Attrs@1,
                        gleam@list:find(_pipe@1, fun(Attr@1) -> case Attr@1 of
                                    {rendered_event_handler, Kind, _} when Kind =:= Event_kind ->
                                        true;

                                    _ ->
                                        false
                                end end)
                    end,
                    case Rendered_event_handler of
                        {ok, {rendered_event_handler, _, Event_id}} ->
                            case sprocket@sprocket:get_handler(Spkt, Event_id) of
                                {ok, {event_handler, _, Handler}} ->
                                    case Handler of
                                        {callback_fn, Cb} ->
                                            Cb();

                                        _ ->
                                            erlang:error(#{gleam_error => todo,
                                                    message => <<"This has not yet been implemented"/utf8>>,
                                                    module => <<"test_helpers"/utf8>>,
                                                    function => <<"render_event"/utf8>>,
                                                    line => 94})
                                    end;

                                _ ->
                                    nil
                            end;

                        _ ->
                            gleam@io:debug(<<"no event handler"/utf8>>),
                            erlang:error(#{gleam_error => panic,
                                    message => <<"panic expression evaluated"/utf8>>,
                                    module => <<"test_helpers"/utf8>>,
                                    function => <<"render_event"/utf8>>,
                                    line => 103})
                    end;

                {error, _} ->
                    gleam@io:debug(<<"no match"/utf8>>),
                    erlang:error(#{gleam_error => panic,
                            message => <<"panic expression evaluated"/utf8>>,
                            module => <<"test_helpers"/utf8>>,
                            function => <<"render_event"/utf8>>,
                            line => 109})
            end;

        none ->
            gleam@io:debug(<<"no rendered"/utf8>>),
            erlang:error(#{gleam_error => panic,
                    message => <<"panic expression evaluated"/utf8>>,
                    module => <<"test_helpers"/utf8>>,
                    function => <<"render_event"/utf8>>,
                    line => 115})
    end,
    Spkt.