sprocket

-module(sprocket@hooks@callback).
-compile([no_auto_import, nowarn_unused_vars]).

-export([callback/4]).

-spec replace_callback(
    sprocket@internal@identifiable_callback:callback_fn(),
    gleam@option:option(list(gleam@dynamic:dynamic()))
) -> sprocket@hooks:callback_result().
replace_callback(Callback_fn, Deps) ->
    {callback_result, Callback_fn, Deps}.

-spec maybe_update_callback(
    sprocket@internal@identifiable_callback:callback_fn(),
    sprocket@hooks:hook_trigger(),
    gleam@option:option(sprocket@hooks:callback_result())
) -> sprocket@hooks:callback_result().
maybe_update_callback(Callback_fn, Trigger, Prev) ->
    case Trigger of
        on_mount ->
            replace_callback(Callback_fn, {some, []});

        on_update ->
            replace_callback(Callback_fn, none);

        {with_deps, Deps} ->
            case Prev of
                {some,
                    {callback_result, _, {some, Prev_deps}} = Prev_callback_result} ->
                    case sprocket@hooks:compare_deps(Prev_deps, Deps) of
                        {changed, _} ->
                            replace_callback(Callback_fn, {some, Deps});

                        unchanged ->
                            Prev_callback_result
                    end;

                {some, Prev_callback_result@1} ->
                    Prev_callback_result@1;

                none ->
                    replace_callback(Callback_fn, {some, Deps});

                _ ->
                    sprocket@internal@exceptions:throw_on_unexpected_hook_result(
                        {<<"handle_callback"/utf8>>, Prev}
                    )
            end
    end.

-spec callback(
    sprocket@context:context(),
    sprocket@internal@identifiable_callback:callback_fn(),
    sprocket@hooks:hook_trigger(),
    fun((sprocket@context:context(), sprocket@internal@identifiable_callback:identifiable_callback()) -> {KKX,
        list(sprocket@element:element())})
) -> {KKX, list(sprocket@element:element())}.
callback(Ctx, Callback_fn, Trigger, Cb) ->
    Init_callback = fun() ->
        {callback,
            sprocket@internal@utils@unique:new(),
            Callback_fn,
            Trigger,
            none}
    end,
    {Ctx@1, {callback, Id, _, _, Prev}, Index} = sprocket@context:fetch_or_init_hook(
        Ctx,
        Init_callback
    ),
    Result = maybe_update_callback(Callback_fn, Trigger, Prev),
    Ctx@2 = sprocket@context:update_hook(
        Ctx@1,
        {callback, Id, erlang:element(2, Result), Trigger, {some, Result}},
        Index
    ),
    Cb(Ctx@2, {identifiable_callback, Id, erlang:element(2, Result)}).