builder

-module(builder@internal@analyzer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/builder/internal/analyzer.gleam").
-export([analyze_module_contents/4, analyze_module_file/1, analyze_project/1]).
-export_type([error/0]).

-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 error() :: {failed_to_read_file, simplifile:file_error()} |
    {failed_to_parse, glance:error()} |
    {failed_to_parse_project_toml, tom:parse_error()}.

-file("src/builder/internal/analyzer.gleam", 50).
?DOC(false).
-spec analyze_module_contents(binary(), binary(), binary(), binary()) -> {ok,
        builder@module:module_()} |
    {error, error()}.
analyze_module_contents(Contents, Module_path, Package_name, Path) ->
    gleam@result:'try'(
        begin
            _pipe = builder@internal@superglance:module(Contents),
            gleam@result:map_error(_pipe, fun(X) -> {failed_to_parse, X} end)
        end,
        fun(Module) ->
            {ok,
                {module,
                    filepath:base_name(Module_path),
                    Package_name,
                    Module_path,
                    erlang:element(2, Module),
                    erlang:element(3, Module),
                    erlang:element(4, Module),
                    erlang:element(5, Module),
                    erlang:element(6, Module),
                    false,
                    Path}}
        end
    ).

-file("src/builder/internal/analyzer.gleam", 18).
?DOC(false).
-spec analyze_module_file(binary()) -> {ok, builder@module:module_()} |
    {error, error()}.
analyze_module_file(Path) ->
    gleam@result:'try'(
        begin
            _pipe = simplifile:read(Path),
            gleam@result:map_error(
                _pipe,
                fun(X) -> {failed_to_read_file, X} end
            )
        end,
        fun(Contents) ->
            Project_root = builder@internal@util:find_project_root_path(Path),
            gleam@result:'try'(
                begin
                    _pipe@1 = simplifile:read(
                        filepath:join(Project_root, <<"gleam.toml"/utf8>>)
                    ),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(X@1) -> {failed_to_read_file, X@1} end
                    )
                end,
                fun(Project_toml) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = tom:parse(Project_toml),
                            gleam@result:map_error(
                                _pipe@2,
                                fun(X@2) ->
                                    {failed_to_parse_project_toml, X@2}
                                end
                            )
                        end,
                        fun(Project_info) ->
                            Package_name@1 = case tom:get_string(
                                Project_info,
                                [<<"name"/utf8>>]
                            ) of
                                {ok, Package_name} -> Package_name;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"builder/internal/analyzer"/utf8>>,
                                                function => <<"analyze_module_file"/utf8>>,
                                                line => 36,
                                                value => _assert_fail,
                                                start => 903,
                                                'end' => 971,
                                                pattern_start => 914,
                                                pattern_end => 930})
                            end,
                            Src_directory = <<(filepath:join(
                                    Project_root,
                                    <<"src"/utf8>>
                                ))/binary,
                                "/"/utf8>>,
                            Gleam_path = filepath:strip_extension(Path),
                            analyze_module_contents(
                                Contents,
                                builder@internal@util:trim_prefix(
                                    Gleam_path,
                                    Src_directory
                                ),
                                Package_name@1,
                                Path
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/builder/internal/analyzer.gleam", 75).
?DOC(false).
-spec analyze_project(binary()) -> gleam@dict:dict(binary(), builder@module:module_()).
analyze_project(Path) ->
    Project_root = builder@internal@util:find_project_root_path(Path),
    Project_src = filepath:join(Project_root, <<"src"/utf8>>),
    Project_packages = begin
        _pipe = Project_root,
        _pipe@1 = filepath:join(_pipe, <<"build"/utf8>>),
        filepath:join(_pipe@1, <<"packages"/utf8>>)
    end,
    Sources_files = gleam@list:filter_map(
        builder@internal@util:scan_walk(Project_src),
        fun(File) -> case filepath:extension(File) =:= {ok, <<"gleam"/utf8>>} of
                true ->
                    {ok, {File, false}};

                false ->
                    {error, nil}
            end end
    ),
    Packages_files = case simplifile_erl:is_directory(Project_packages) of
        {ok, _} ->
            gleam@list:filter_map(
                builder@internal@util:scan_walk(Project_packages),
                fun(File@1) ->
                    case filepath:extension(File@1) =:= {ok, <<"gleam"/utf8>>} of
                        true ->
                            {ok, {File@1, true}};

                        false ->
                            {error, nil}
                    end
                end
            );

        _ ->
            []
    end,
    Files = begin
        _pipe@2 = Sources_files,
        lists:append(_pipe@2, Packages_files)
    end,
    Modules@1 = begin
        _pipe@3 = gleam@list:map(
            Files,
            fun(File@2) ->
                gleam@result:map(
                    analyze_module_file(erlang:element(1, File@2)),
                    fun(Module) ->
                        {module,
                            erlang:element(2, Module),
                            erlang:element(3, Module),
                            erlang:element(4, Module),
                            erlang:element(5, Module),
                            erlang:element(6, Module),
                            erlang:element(7, Module),
                            erlang:element(8, Module),
                            erlang:element(9, Module),
                            erlang:element(2, File@2),
                            erlang:element(11, Module)}
                    end
                )
            end
        ),
        gleam@list:fold(
            _pipe@3,
            maps:new(),
            fun(Modules, Module@1) -> case Module@1 of
                    {ok, Module@2} ->
                        gleam@dict:insert(
                            Modules,
                            erlang:element(4, Module@2),
                            Module@2
                        );

                    _ ->
                        Modules
                end end
        )
    end,
    Modules@1.