-module(sprocket@test_helpers).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

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

-type event() :: click_event.

-spec connect(sprocket@context:element()) -> gleam@erlang@process:subject(sprocket@runtime:message()).
connect(View) ->
    _assert_subject = sprocket@runtime:start(
        View,
        {updater, fun(_) -> {ok, nil} end},
        none
    ),
    {ok, Spkt} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"sprocket/test_helpers"/utf8>>,
                        function => <<"connect"/utf8>>,
                        line => 15})
    end,
    Spkt.

-spec render_html(gleam@erlang@process:subject(sprocket@runtime:message())) -> {gleam@erlang@process:subject(sprocket@runtime:message()),
    binary()}.
render_html(Spkt) ->
    sprocket@render:renderer(
        sprocket@renderers@html:html_renderer(),
        fun(Render_html) ->
            Html = begin
                _pipe = sprocket@runtime:reconcile_immediate(Spkt),
                Render_html(_pipe)
            end,
            {Spkt, Html}
        end
    ).

-spec render_event(
    gleam@erlang@process:subject(sprocket@runtime:message()),
    event(),
    binary()
) -> gleam@erlang@process:subject(sprocket@runtime:message()).
render_event(Spkt, Event, Html_id) ->
    case sprocket@runtime:get_reconciled(Spkt) of
        {some, Reconciled} ->
            Found = sprocket@internal@reconcilers@recursive:find(
                Reconciled,
                fun(El) -> case El of
                        {reconciled_element, _, _, Attrs, _} ->
                            Matching_id_attr = begin
                                _pipe = Attrs,
                                gleam@list:find(_pipe, fun(Attr) -> case Attr of
                                            {reconciled_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, {reconciled_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
                                    {reconciled_event_handler, Kind, _} when Kind =:= Event_kind ->
                                        true;

                                    _ ->
                                        false
                                end end)
                    end,
                    case Rendered_event_handler of
                        {ok, {reconciled_event_handler, _, Event_id}} ->
                            case sprocket@runtime:process_event_immediate(
                                Spkt,
                                Event_id,
                                none
                            ) of
                                {ok, _} ->
                                    Spkt;

                                _ ->
                                    erlang:error(#{gleam_error => panic,
                                            message => <<"panic expression evaluated"/utf8>>,
                                            module => <<"sprocket/test_helpers"/utf8>>,
                                            function => <<"render_event"/utf8>>,
                                            line => 80})
                            end;

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

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

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