-module(gleam_synapses@model@net_elems@layer@layer).
-compile(no_auto_import).

-export([init/4, output/3, back_propagated/5, generator/2]).

-spec pmap(gleam_zlists@interop:z_list(FXB), fun((FXB) -> FXD)) -> gleam_zlists@interop:z_list(FXD).
pmap(Zl, F) ->
    _pipe = Zl,
    _pipe@1 = gleam_zlists:to_list(_pipe),
    _pipe@2 = native_parmap:parmap(_pipe@1, F),
    gleam_zlists:of_list(_pipe@2).

-spec init(
    integer(),
    integer(),
    gleam_synapses@model@net_elems@activation@activation:activation(),
    fun(() -> fun(() -> float()))
) -> gleam_zlists@interop:z_list(gleam_synapses@model@net_elems@neuron@neuron:neuron()).
init(Input_size, Output_size, Activation_f, Weight_init_f) ->
    _pipe = gleam_zlists:indices(),
    _pipe@1 = gleam_zlists:take(_pipe, Output_size),
    gleam_zlists:map(
        _pipe@1,
        fun(_) ->
            gleam_synapses@model@net_elems@neuron@neuron:init(
                Input_size,
                Activation_f,
                Weight_init_f()
            )
        end
    ).

-spec output(
    gleam_zlists@interop:z_list(gleam_synapses@model@net_elems@neuron@neuron:neuron()),
    gleam_zlists@interop:z_list(float()),
    boolean()
) -> gleam_zlists@interop:z_list(float()).
output(Layer, Input_val, In_parallel) ->
    case In_parallel of
        true ->
            pmap(
                Layer,
                fun(X) ->
                    gleam_synapses@model@net_elems@neuron@neuron:output(
                        X,
                        Input_val
                    )
                end
            );

        false ->
            gleam_zlists:map(
                Layer,
                fun(X@1) ->
                    gleam_synapses@model@net_elems@neuron@neuron:output(
                        X@1,
                        Input_val
                    )
                end
            )
    end.

-spec back_propagated(
    gleam_zlists@interop:z_list(gleam_synapses@model@net_elems@neuron@neuron:neuron()),
    float(),
    gleam_zlists@interop:z_list(float()),
    gleam_zlists@interop:z_list({float(), float()}),
    boolean()
) -> {gleam_zlists@interop:z_list(float()),
      gleam_zlists@interop:z_list(gleam_synapses@model@net_elems@neuron@neuron:neuron())}.
back_propagated(Layer, Learning_rate, Input_val, Output_with_error, In_parallel) ->
    F = fun(T) ->
        {A, B} = T,
        gleam_synapses@model@net_elems@neuron@neuron:back_propagated(
            B,
            Learning_rate,
            Input_val,
            A
        )
    end,
    {Errors_multi, New_layer} = case In_parallel of
        true ->
            _pipe = gleam_zlists:zip(Output_with_error, Layer),
            _pipe@1 = pmap(_pipe, F),
            gleam_zlists:unzip(_pipe@1);

        false ->
            _pipe@2 = gleam_zlists:zip(Output_with_error, Layer),
            _pipe@3 = gleam_zlists:map(_pipe@2, F),
            gleam_zlists:unzip(_pipe@3)
    end,
    Errors = gleam_zlists:reduce(
        Errors_multi,
        begin
            _pipe@4 = gleam_zlists:indices(),
            gleam_zlists:map(_pipe@4, fun(_) -> 0.0 end)
        end,
        fun(X, Acc) ->
            _pipe@5 = gleam_zlists:zip(Acc, X),
            gleam_zlists:map(
                _pipe@5,
                fun(T@1) ->
                    {A@1, B@1} = T@1,
                    A@1
                    + B@1
                end
            )
        end
    ),
    {Errors, New_layer}.

-spec generator(integer(), integer()) -> minigen:generator(gleam_zlists@interop:z_list(gleam_synapses@model@net_elems@neuron@neuron:neuron())).
generator(Input_size, Output_size) ->
    _pipe = gleam_synapses@model@net_elems@neuron@neuron:generator(Input_size),
    _pipe@1 = minigen:list(_pipe, Output_size),
    minigen:map(_pipe@1, fun gleam_zlists:of_list/1).