-module(caffeine_lang@codegen@graph_data).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/codegen/graph_data.gleam").
-export([generate/1]).
-export_type([graph_node/0, graph_edge/0, graph_data/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.

-type graph_node() :: {graph_node,
        binary(),
        binary(),
        binary(),
        binary(),
        binary()}.

-type graph_edge() :: {graph_edge, binary(), binary(), binary()}.

-type graph_data() :: {graph_data, list(graph_node()), list(graph_edge())}.

-file("src/caffeine_lang/codegen/graph_data.gleam", 43).
?DOC(" Builds graph nodes from all IRs.\n").
-spec build_nodes(
    list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved()))
) -> list(graph_node()).
build_nodes(Irs) ->
    gleam@list:map(
        Irs,
        fun(Ir) ->
            {graph_node,
                caffeine_lang@linker@ir:ir_to_identifier(Ir),
                erlang:element(2, erlang:element(2, erlang:element(2, Ir))),
                erlang:element(2, erlang:element(4, erlang:element(2, Ir))),
                erlang:element(2, erlang:element(3, erlang:element(2, Ir))),
                erlang:element(2, erlang:element(6, erlang:element(2, Ir)))}
        end
    ).

-file("src/caffeine_lang/codegen/graph_data.gleam", 58).
?DOC(" Builds graph edges from IRs that have DependencyRelations.\n").
-spec build_edges(
    list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved()))
) -> list(graph_edge()).
build_edges(Irs) ->
    _pipe = Irs,
    _pipe@1 = gleam@list:filter(
        _pipe,
        fun(Ir) ->
            gleam@list:contains(erlang:element(4, Ir), dependency_relations)
        end
    ),
    gleam@list:flat_map(
        _pipe@1,
        fun(Ir@1) ->
            Source_id = caffeine_lang@linker@ir:ir_to_identifier(Ir@1),
            case caffeine_lang@linker@ir:get_dependency_fields(
                erlang:element(6, Ir@1)
            ) of
                none ->
                    [];

                {some, Dep} ->
                    Hard_edges = begin
                        _pipe@2 = gleam_stdlib:map_get(
                            erlang:element(2, Dep),
                            hard
                        ),
                        _pipe@3 = gleam@result:unwrap(_pipe@2, []),
                        gleam@list:map(
                            _pipe@3,
                            fun(Target) ->
                                {graph_edge, Source_id, Target, <<"hard"/utf8>>}
                            end
                        )
                    end,
                    Soft_edges = begin
                        _pipe@4 = gleam_stdlib:map_get(
                            erlang:element(2, Dep),
                            soft
                        ),
                        _pipe@5 = gleam@result:unwrap(_pipe@4, []),
                        gleam@list:map(
                            _pipe@5,
                            fun(Target@1) ->
                                {graph_edge,
                                    Source_id,
                                    Target@1,
                                    <<"soft"/utf8>>}
                            end
                        )
                    end,
                    lists:append(Hard_edges, Soft_edges)
            end
        end
    ).

-file("src/caffeine_lang/codegen/graph_data.gleam", 36).
?DOC(
    " Generates structured graph data from resolved IRs.\n"
    " Nodes are derived from all IRs; edges come from DependencyRelations artifacts.\n"
).
-spec generate(
    list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved()))
) -> graph_data().
generate(Irs) ->
    Nodes = build_nodes(Irs),
    Edges = build_edges(Irs),
    {graph_data, Nodes, Edges}.