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

-export([f2e/1, c_atom/1, p_atom/1, c_case/2, c_cons/2, p_cons/2, c_float/1, p_float/1, c_fname/2, c_int/1, p_int/1, list_elements/1, c_module/4, c_nil/0, p_nil/0, c_receive/1, c_seq/2, c_var/1, p_var/1, c_apply/2, c_apply_anonymous/2, c_call/3, make_list/1, c_binary/1, c_tuple/1, c_clause/2, c_clause_w_guard/3, c_fun/2, c_let/3, p_tuple/1]).
-export_type([module_def/0, module_attribute/0, clause/0, expression/0, pattern/0, function_decl/0, function_/0, c_erl/0, bit_str/0, we_do_not_pass_the_tail/0]).

-type module_def() :: any().

-type module_attribute() :: any().

-type clause() :: any().

-opaque expression() :: {apply_expr, c_erl()} |
    {atom_expr, c_erl()} |
    {binary_expr, c_erl()} |
    {case_expr, c_erl()} |
    {do_expr, c_erl()} |
    {float_expr, c_erl()} |
    {function_expr, c_erl()} |
    {int_expr, c_erl()} |
    {let_expr, c_erl()} |
    {list_expr, c_erl()} |
    {receive_expr, c_erl()} |
    {tuple_expr, c_erl()} |
    {var_expr, c_erl()}.

-opaque pattern() :: {atom_pattern, c_erl()} |
    {float_pattern, c_erl()} |
    {int_pattern, c_erl()} |
    {list_pattern, c_erl()} |
    {nil_pattern, c_erl()} |
    {tuple_pattern, c_erl()} |
    {var_pattern, c_erl()}.

-type function_decl() :: any().

-opaque function_() :: {function, c_erl()}.

-type c_erl() :: any().

-type bit_str() :: any().

-type we_do_not_pass_the_tail() :: none.

-spec f2e(function_()) -> expression().
f2e(F) ->
    {function_expr, erlang:element(2, F)}.

-spec to_atom(binary()) -> c_erl().
to_atom(Name) ->
    _pipe = Name,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    cerl:c_atom(_pipe@1).

-spec c_atom(binary()) -> expression().
c_atom(Name) ->
    _pipe = Name,
    _pipe@1 = to_atom(_pipe),
    {atom_expr, _pipe@1}.

-spec p_atom(binary()) -> pattern().
p_atom(Name) ->
    _pipe = Name,
    _pipe@1 = to_atom(_pipe),
    {atom_pattern, _pipe@1}.

-spec c_case(expression(), list(clause())) -> expression().
c_case(Expr, Clauses) ->
    _pipe = cerl:c_case(erlang:element(2, Expr), Clauses),
    {case_expr, _pipe}.

-spec c_cons(expression(), expression()) -> expression().
c_cons(Head, Tail) ->
    _pipe = cerl:c_cons(erlang:element(2, Head), erlang:element(2, Tail)),
    {list_expr, _pipe}.

-spec p_cons(pattern(), pattern()) -> pattern().
p_cons(Head, Tail) ->
    _pipe = cerl:c_cons(erlang:element(2, Head), erlang:element(2, Tail)),
    {list_pattern, _pipe}.

-spec c_float(float()) -> expression().
c_float(Value) ->
    _pipe = Value,
    _pipe@1 = cerl:c_float(_pipe),
    {float_expr, _pipe@1}.

-spec p_float(float()) -> pattern().
p_float(Value) ->
    _pipe = Value,
    _pipe@1 = cerl:c_float(_pipe),
    {float_pattern, _pipe@1}.

-spec c_fname(binary(), integer()) -> function_decl().
c_fname(Name, Arity) ->
    _pipe = Name,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    cerl:c_fname(_pipe@1, Arity).

-spec c_int(integer()) -> expression().
c_int(Value) ->
    _pipe = Value,
    _pipe@1 = cerl:c_int(_pipe),
    {int_expr, _pipe@1}.

-spec p_int(integer()) -> pattern().
p_int(Value) ->
    _pipe = Value,
    _pipe@1 = cerl:c_int(_pipe),
    {int_pattern, _pipe@1}.

-spec list_elements(expression()) -> list(expression()).
list_elements(List) ->
    _pipe = erlang:element(2, List),
    _pipe@1 = cerl:list_elements(_pipe),
    gleam@list:map(_pipe@1, fun(Field@0) -> {var_expr, Field@0} end).

-spec c_module(
    binary(),
    list(function_decl()),
    list(module_attribute()),
    list({function_decl(), function_()})
) -> module_def().
c_module(Name, Exports, Attributes, Definitions) ->
    _pipe = Definitions,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Def) ->
            {Decl, Fun} = Def,
            {Decl, erlang:element(2, Fun)}
        end
    ),
    cerl:c_module(to_atom(Name), Exports, Attributes, _pipe@1).

-spec c_nil() -> expression().
c_nil() ->
    _pipe = cerl:c_nil(),
    {list_expr, _pipe}.

-spec p_nil() -> pattern().
p_nil() ->
    _pipe = cerl:c_nil(),
    {nil_pattern, _pipe}.

-spec c_receive(list(clause())) -> expression().
c_receive(Clauses) ->
    _pipe = Clauses,
    _pipe@1 = cerl:c_receive(_pipe),
    {receive_expr, _pipe@1}.

-spec c_seq(expression(), expression()) -> expression().
c_seq(Arg, Body) ->
    _pipe = cerl:c_seq(erlang:element(2, Arg), erlang:element(2, Body)),
    {do_expr, _pipe}.

-spec c_var(binary()) -> expression().
c_var(Name) ->
    _pipe = Name,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    _pipe@2 = cerl:c_var(_pipe@1),
    {var_expr, _pipe@2}.

-spec p_var(binary()) -> pattern().
p_var(Name) ->
    _pipe = Name,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    _pipe@2 = cerl:c_var(_pipe@1),
    {var_pattern, _pipe@2}.

-spec unwrap_expressions(list(expression())) -> list(c_erl()).
unwrap_expressions(Expressions) ->
    _pipe = Expressions,
    gleam@list:map(_pipe, fun(E) -> erlang:element(2, E) end).

-spec c_apply(function_decl(), list(expression())) -> expression().
c_apply(F_def, Arguments) ->
    _pipe = cerl:c_apply(F_def, unwrap_expressions(Arguments)),
    {apply_expr, _pipe}.

-spec c_apply_anonymous(expression(), list(expression())) -> expression().
c_apply_anonymous(Function, Arguments) ->
    _pipe = cerl:c_apply(
        erlang:element(2, Function),
        unwrap_expressions(Arguments)
    ),
    {receive_expr, _pipe}.

-spec c_call(binary(), binary(), list(expression())) -> expression().
c_call(Module, Name, Arguments) ->
    _pipe = cerl:c_call(
        to_atom(Module),
        to_atom(Name),
        unwrap_expressions(Arguments)
    ),
    {receive_expr, _pipe}.

-spec make_list(list(expression())) -> expression().
make_list(Expressions) ->
    _pipe = Expressions,
    _pipe@1 = unwrap_expressions(_pipe),
    _pipe@2 = cerl:make_list(_pipe@1, none),
    {list_expr, _pipe@2}.

-spec collect_segments(bitstring(), list(bit_str())) -> list(bit_str()).
collect_segments(Bs, Result) ->
    case Bs of
        <<>> ->
            gleam@list:reverse(Result);

        <<B:8, Tail/binary>> ->
            collect_segments(
                Tail,
                [cerl:c_bitstr(
                        cerl:c_int(B),
                        cerl:c_int(8),
                        cerl:c_int(1),
                        to_atom(<<"integer"/utf8>>),
                        erlang:element(
                            2,
                            make_list(
                                [c_atom(<<"unsigned"/utf8>>),
                                    c_atom(<<"big"/utf8>>)]
                            )
                        )
                    ) |
                    Result]
            );

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Unexpected tail in collect_segment"/utf8>>,
                    module => <<"gen_core_erlang"/utf8>>,
                    function => <<"collect_segments"/utf8>>,
                    line => 132})
    end.

-spec c_binary(binary()) -> expression().
c_binary(String) ->
    _pipe = <<String/binary>>,
    _pipe@1 = collect_segments(_pipe, []),
    _pipe@2 = cerl:c_binary(_pipe@1),
    {binary_expr, _pipe@2}.

-spec c_tuple(list(expression())) -> expression().
c_tuple(Values) ->
    _pipe = Values,
    _pipe@1 = unwrap_expressions(_pipe),
    _pipe@2 = cerl:c_tuple(_pipe@1),
    {tuple_expr, _pipe@2}.

-spec unwrap_patterns(list(pattern())) -> list(c_erl()).
unwrap_patterns(Patterns) ->
    _pipe = Patterns,
    gleam@list:map(_pipe, fun(P) -> erlang:element(2, P) end).

-spec c_clause(list(pattern()), expression()) -> clause().
c_clause(Patterns, Expr) ->
    _pipe = Patterns,
    _pipe@1 = unwrap_patterns(_pipe),
    cerl:c_clause(_pipe@1, erlang:element(2, Expr)).

-spec c_clause_w_guard(list(pattern()), expression(), expression()) -> clause().
c_clause_w_guard(Patterns, Guard, Expr) ->
    _pipe = Patterns,
    _pipe@1 = unwrap_patterns(_pipe),
    cerl:c_clause(_pipe@1, erlang:element(2, Guard), erlang:element(2, Expr)).

-spec c_fun(list(pattern()), expression()) -> function_().
c_fun(Arguments, Body) ->
    _pipe = Arguments,
    _pipe@1 = unwrap_patterns(_pipe),
    _pipe@2 = cerl:c_fun(_pipe@1, erlang:element(2, Body)),
    {function, _pipe@2}.

-spec c_let(list(pattern()), expression(), expression()) -> expression().
c_let(Variables, Argument, Body) ->
    _pipe = Variables,
    _pipe@1 = unwrap_patterns(_pipe),
    _pipe@2 = cerl:c_let(
        _pipe@1,
        erlang:element(2, Argument),
        erlang:element(2, Body)
    ),
    {let_expr, _pipe@2}.

-spec p_tuple(list(pattern())) -> pattern().
p_tuple(Values) ->
    _pipe = Values,
    _pipe@1 = unwrap_patterns(_pipe),
    _pipe@2 = cerl:c_tuple(_pipe@1),
    {tuple_pattern, _pipe@2}.