glimpse

-module(glimpse).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([load_module/2, filter_new_dependencies/2, load_package/2]).
-export_type([module_/0, package/0, load_error/1]).

-type module_() :: {module, binary(), glance:module_(), list(binary())}.

-type package() :: {package, binary(), gleam@dict:dict(binary(), module_())}.

-type load_error(IUF) :: {load_error, IUF} |
    {parse_error, glance:error(), binary(), binary()}.

-spec load_module(glance:module_(), binary()) -> module_().
load_module(Module, Name) ->
    _pipe = erlang:element(2, Module),
    _pipe@1 = gleam@list:map(_pipe, fun(Import_def) -> case Import_def of
                {definition, _, Import_} ->
                    erlang:element(2, Import_)
            end end),
    {module, Name, Module, _pipe@1}.

-spec filter_new_dependencies(module_(), package()) -> list(binary()).
filter_new_dependencies(Module, Package) ->
    _pipe = erlang:element(4, Module),
    gleam@list:filter(
        _pipe,
        fun(Dep) -> not gleam@dict:has_key(erlang:element(3, Package), Dep) end
    ).

-spec load_module_recurse(
    package(),
    list(binary()),
    fun((binary()) -> {ok, binary()} | {error, IUO})
) -> {ok, package()} | {error, load_error(IUO)}.
load_module_recurse(Package, Modules, Loader) ->
    case Modules of
        [] ->
            {ok, Package};

        [Module_name | Rest] ->
            case gleam@dict:has_key(erlang:element(3, Package), Module_name) of
                true ->
                    load_module_recurse(Package, Rest, Loader);

                false ->
                    gleam@result:'try'(
                        begin
                            _pipe = Loader(Module_name),
                            gleam@result:map_error(
                                _pipe,
                                fun(Field@0) -> {load_error, Field@0} end
                            )
                        end,
                        fun(Module_content) ->
                            gleam@result:'try'(
                                begin
                                    _pipe@1 = glance:module(Module_content),
                                    gleam@result:map_error(
                                        _pipe@1,
                                        fun(_capture) ->
                                            {parse_error,
                                                _capture,
                                                Module_name,
                                                Module_content}
                                        end
                                    )
                                end,
                                fun(Glance_module) ->
                                    Glimpse_module = load_module(
                                        Glance_module,
                                        Module_name
                                    ),
                                    Unknown_dependencies = filter_new_dependencies(
                                        Glimpse_module,
                                        Package
                                    ),
                                    Recurse_package = erlang:setelement(
                                        3,
                                        Package,
                                        gleam@dict:insert(
                                            erlang:element(3, Package),
                                            Module_name,
                                            Glimpse_module
                                        )
                                    ),
                                    load_module_recurse(
                                        Recurse_package,
                                        lists:append(Unknown_dependencies, Rest),
                                        Loader
                                    )
                                end
                            )
                        end
                    )
            end
    end.

-spec load_package(binary(), fun((binary()) -> {ok, binary()} | {error, IUG})) -> {ok,
        package()} |
    {error, load_error(IUG)}.
load_package(Package_name, Loader) ->
    Package = {package, Package_name, gleam@dict:new()},
    load_module_recurse(Package, [Package_name], Loader).