search_algorithms_gleam

-module(internal@generalized_search).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/generalized_search.gleam").
-export([search_until_found/3, generalized_search/6]).
-export_type([search_state/2]).

-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 search_state(GET, GEU) :: {search_state,
        {integer(), GEU},
        internal@search_container:search_container(GEU),
        gleam@set:set(GET),
        gleam@dict:dict(GET, list({integer(), GEU}))}.

-file("src/internal/generalized_search.gleam", 33).
?DOC(false).
-spec search_until_found(
    fun((GEV) -> {ok, GEV} | {error, nil}),
    fun((GEV) -> boolean()),
    GEV
) -> {ok, GEV} | {error, nil}.
search_until_found(Get_next_states, Has_found_end, State) ->
    case Has_found_end(State) of
        true ->
            {ok, State};

        false ->
            _pipe = Get_next_states(State),
            gleam@result:'try'(
                _pipe,
                fun(_capture) ->
                    search_until_found(Get_next_states, Has_found_end, _capture)
                end
            )
    end.

-file("src/internal/generalized_search.gleam", 46).
?DOC(false).
-spec get_next_search_state(
    fun((list({integer(), GFA}), list({integer(), GFA})) -> boolean()),
    fun(({integer(), GFA}) -> GFD),
    fun(({integer(), GFA}) -> list({integer(), GFA})),
    search_state(GFD, GFA)
) -> {ok, search_state(GFD, GFA)} | {error, nil}.
get_next_search_state(Is_better, Make_key, Get_next_states, Current) ->
    Update_queue_paths = fun(Queue_and_paths, State) ->
        {Queue, Paths} = Queue_and_paths,
        Key = Make_key(State),
        case gleam@set:contains(erlang:element(4, Current), Key) of
            true ->
                {Queue, Paths};

            false ->
                Steps_so_far@1 = case gleam_stdlib:map_get(
                    erlang:element(5, Current),
                    Make_key(erlang:element(2, Current))
                ) of
                    {ok, Steps_so_far} -> Steps_so_far;
                    _assert_fail ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"internal/generalized_search"/utf8>>,
                                    function => <<"get_next_search_state"/utf8>>,
                                    line => 62,
                                    value => _assert_fail,
                                    start => 2239,
                                    'end' => 2329,
                                    pattern_start => 2250,
                                    pattern_end => 2266})
                end,
                Updated_queue = internal@search_container:push(Queue, State),
                Updated_paths = gleam@dict:insert(
                    Paths,
                    Key,
                    [State | Steps_so_far@1]
                ),
                case gleam_stdlib:map_get(Paths, Key) of
                    {ok, Path} ->
                        case Is_better(Path, [State | Steps_so_far@1]) of
                            true ->
                                {Updated_queue, Updated_paths};

                            false ->
                                {Queue, Paths}
                        end;

                    {error, nil} ->
                        {Updated_queue, Updated_paths}
                end
        end
    end,
    New_queue_paths = fun() ->
        Next_states = Get_next_states(erlang:element(2, Current)),
        gleam@list:fold(
            Next_states,
            {erlang:element(3, Current), erlang:element(5, Current)},
            Update_queue_paths
        )
    end,
    {New_queue, New_paths} = New_queue_paths(),
    _pipe = New_queue,
    _pipe@1 = internal@search_container:pop(_pipe),
    _pipe@2 = gleam@result:map(
        _pipe@1,
        fun(State_and_container) ->
            {State@1, Container} = State_and_container,
            {search_state,
                State@1,
                Container,
                gleam@set:insert(erlang:element(4, Current), Make_key(State@1)),
                New_paths}
        end
    ),
    gleam@result:'try'(
        _pipe@2,
        fun(Search_state) ->
            case gleam@set:contains(
                erlang:element(4, Current),
                Make_key(erlang:element(2, Search_state))
            ) of
                true ->
                    get_next_search_state(
                        Is_better,
                        Make_key,
                        Get_next_states,
                        Search_state
                    );

                false ->
                    {ok, Search_state}
            end
        end
    ).

-file("src/internal/generalized_search.gleam", 117).
?DOC(false).
-spec generalized_search(
    internal@search_container:search_container(GFL),
    fun(({integer(), GFL}) -> any()),
    fun((list({integer(), GFL}), list({integer(), GFL})) -> boolean()),
    fun(({integer(), GFL}) -> list({integer(), GFL})),
    fun(({integer(), GFL}) -> boolean()),
    {integer(), GFL}
) -> {ok, list({integer(), GFL})} | {error, nil}.
generalized_search(
    Search_container,
    Make_key,
    Is_better,
    Get_next_states,
    Has_found_end,
    Initial_state
) ->
    Initial_key = Make_key(Initial_state),
    Search_state = {search_state,
        Initial_state,
        Search_container,
        gleam@set:from_list([Initial_key]),
        maps:from_list([{Initial_key, []}])},
    End_result = search_until_found(
        fun(_capture) ->
            get_next_search_state(
                Is_better,
                Make_key,
                Get_next_states,
                _capture
            )
        end,
        fun(Search_state@1) ->
            Has_found_end(erlang:element(2, Search_state@1))
        end,
        Search_state
    ),
    Get_steps = fun(Search_state@2) ->
        Steps@1 = case gleam_stdlib:map_get(
            erlang:element(5, Search_state@2),
            Make_key(erlang:element(2, Search_state@2))
        ) of
            {ok, Steps} -> Steps;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"internal/generalized_search"/utf8>>,
                            function => <<"generalized_search"/utf8>>,
                            line => 144,
                            value => _assert_fail,
                            start => 4704,
                            'end' => 4793,
                            pattern_start => 4715,
                            pattern_end => 4724})
        end,
        Steps@1
    end,
    gleam@result:map(End_result, fun(St) -> _pipe = St,
            _pipe@1 = Get_steps(_pipe),
            lists:reverse(_pipe@1) end).