-module(gleam_synapses@model@encoding@preprocessor).
-compile(no_auto_import).

-export([init/2, encode/2, decode/2, to_json/1, of_json/1]).

-spec lazy_realization(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute())
) -> gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()).
lazy_realization(Preprocessor) ->
    serialized(Preprocessor),
    Preprocessor.

-spec updated_f(
    gleam_synapses@model@encoding@serialization:attribute(),
    gleam@map:map_(binary(), binary())
) -> gleam_synapses@model@encoding@serialization:attribute().
updated_f(Attr, Datapoint) ->
    case Attr of
        {discrete_attribute, _, _} ->
            gleam_synapses@model@encoding@discrete_attribute:updated(
                Attr,
                Datapoint
            );

        {continuous_attribute, _, _, _} ->
            gleam_synapses@model@encoding@continuous_attribute:updated(
                Attr,
                Datapoint
            )
    end.

-spec updated(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()),
    gleam@map:map_(binary(), binary())
) -> gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()).
updated(Preprocessor, Datapoint) ->
    gleam_zlists:map(Preprocessor, fun(X) -> updated_f(X, Datapoint) end).

-spec init_f(binary(), boolean(), gleam@map:map_(binary(), binary())) -> gleam_synapses@model@encoding@serialization:attribute().
init_f(Key, Is_discrete, Dataset_head) ->
    {ok, Str_val} = gleam@map:get(Dataset_head, Key),
    case Is_discrete of
        true ->
            {discrete_attribute, Key, gleam_zlists:singleton(Str_val)};

        false ->
            V = gleam_synapses@model@encoding@continuous_attribute:parse(
                Str_val
            ),
            {continuous_attribute, Key, V, V}
    end.

-spec init(
    gleam_zlists@interop:z_list({binary(), boolean()}),
    gleam_zlists@interop:z_list(gleam@map:map_(binary(), binary()))
) -> gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()).
init(Keys_with_flags, Dataset) ->
    {ok, {Dataset_head, Dataset_tail}} = gleam_zlists:uncons(Dataset),
    Init_preprocessor = gleam_zlists:map(
        Keys_with_flags,
        fun(T) -> {Key, Is_discrete} = T,
            init_f(Key, Is_discrete, Dataset_head) end
    ),
    lazy_realization(
        gleam_zlists:reduce(
            Dataset_tail,
            Init_preprocessor,
            fun(X, Acc) -> updated(Acc, X) end
        )
    ).

-spec encode(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()),
    gleam@map:map_(binary(), binary())
) -> gleam_zlists@interop:z_list(float()).
encode(Preprocessor, Datapoint) ->
    gleam_zlists:flat_map(Preprocessor, fun(Attr) -> case Attr of
                {discrete_attribute, Key, _} ->
                    {ok, V} = gleam@map:get(Datapoint, Key),
                    gleam_synapses@model@encoding@discrete_attribute:encode(
                        Attr,
                        V
                    );

                {continuous_attribute, Key@1, _, _} ->
                    {ok, V@1} = gleam@map:get(Datapoint, Key@1),
                    gleam_synapses@model@encoding@continuous_attribute:encode(
                        Attr,
                        V@1
                    )
            end end).

-spec decode_acc_f(
    gleam_synapses@model@encoding@serialization:attribute(),
    {gleam_zlists@interop:z_list(float()),
     gleam_zlists@interop:z_list({binary(), binary()})}
) -> {gleam_zlists@interop:z_list(float()),
      gleam_zlists@interop:z_list({binary(), binary()})}.
decode_acc_f(Attr, Acc) ->
    {Unprocessed_floats, Processed_ks_vs} = Acc,
    {Key@2, Split_index} = case Attr of
        {discrete_attribute, Key, Values} ->
            {Key, gleam_zlists:count(Values)};

        {continuous_attribute, Key@1, _, _} ->
            {Key@1, 1}
    end,
    {Encoded_values_ls, Next_floats_zls} = gleam_zlists:split(
        Unprocessed_floats,
        Split_index
    ),
    Encoded_values_zls = gleam_zlists:of_list(Encoded_values_ls),
    Decoded_value = case Attr of
        {discrete_attribute, _, _} ->
            gleam_synapses@model@encoding@discrete_attribute:decode(
                Attr,
                Encoded_values_zls
            );

        {continuous_attribute, _, _, _} ->
            gleam_synapses@model@encoding@continuous_attribute:decode(
                Attr,
                Encoded_values_zls
            )
    end,
    Next_ks_vs = gleam_zlists:cons(Processed_ks_vs, {Key@2, Decoded_value}),
    {Next_floats_zls, Next_ks_vs}.

-spec decode(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()),
    gleam_zlists@interop:z_list(float())
) -> gleam@map:map_(binary(), binary()).
decode(Preprocessor, Encoded_datapoint) ->
    gleam@map:from_list(
        gleam_zlists:to_list(
            gleam@pair:second(
                gleam_zlists:reduce(
                    Preprocessor,
                    {Encoded_datapoint, gleam_zlists:new()},
                    fun(X, Acc) -> decode_acc_f(X, Acc) end
                )
            )
        )
    ).

-spec serialized(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute())
) -> list(gleam_synapses@model@encoding@serialization:f_sharp_attribute_serialized()).
serialized(Preprocessor) ->
    gleam_zlists:to_list(
        gleam_zlists:map(Preprocessor, fun(Attr) -> case Attr of
                    {discrete_attribute, _, _} ->
                        {f_sharp_attribute_serialized,
                         <<"SerializableDiscrete"/utf8>>,
                         [gleam_synapses@model@encoding@discrete_attribute:serialized(
                              Attr
                          )]};

                    {continuous_attribute, _, _, _} ->
                        {f_sharp_attribute_serialized,
                         <<"SerializableContinuous"/utf8>>,
                         [gleam_synapses@model@encoding@continuous_attribute:serialized(
                              Attr
                          )]}
                end end)
    ).

-spec deserialized(
    list(gleam_synapses@model@encoding@serialization:f_sharp_attribute_serialized())
) -> gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()).
deserialized(Preprocessor_serialized) ->
    gleam_zlists:map(
        gleam_zlists:of_list(Preprocessor_serialized),
        fun(X) -> {f_sharp_attribute_serialized, Case_, Fields} = X,
            {ok, Serialized_attr} = gleam@list:head(Fields),
            case Case_ of
                <<"SerializableDiscrete"/utf8>> ->
                    gleam_synapses@model@encoding@discrete_attribute:deserialized(
                        Serialized_attr
                    );

                <<"SerializableContinuous"/utf8>> ->
                    gleam_synapses@model@encoding@continuous_attribute:deserialized(
                        Serialized_attr
                    )
            end end
    ).

-spec json_encoded(
    list(gleam_synapses@model@encoding@serialization:f_sharp_attribute_serialized())
) -> gleam_synapses@model@edited_jsone:json_value().
json_encoded(Preprocessor_serialized) ->
    Discr_or_contin_json_encoded = fun(Fsharp_serialized_attr) ->
        {f_sharp_attribute_serialized, Case_, Fields} = Fsharp_serialized_attr,
        {ok, Serialized_attr} = gleam@list:head(Fields),
        Serialized_attr_json_encoded = case Case_ of
            <<"SerializableDiscrete"/utf8>> ->
                gleam_synapses@model@encoding@discrete_attribute:json_encoded(
                    Serialized_attr
                );

            <<"SerializableContinuous"/utf8>> ->
                gleam_synapses@model@encoding@continuous_attribute:json_encoded(
                    Serialized_attr
                )
        end,
        gleam_synapses@model@edited_jsone:object(
            [{<<"Case"/utf8>>, gleam_synapses@model@edited_jsone:string(Case_)},
             {<<"Fields"/utf8>>,
              gleam_synapses@model@edited_jsone:array(
                  Fields,
                  fun(_) -> Serialized_attr_json_encoded end
              )}]
        )
    end,
    gleam_synapses@model@edited_jsone:array(
        Preprocessor_serialized,
        Discr_or_contin_json_encoded
    ).

-spec json_decoder() -> decode:decoder(list(gleam_synapses@model@encoding@serialization:f_sharp_attribute_serialized())).
json_decoder() ->
    Discr_or_contin_json_decoder = decode:one_of(
        [gleam_synapses@model@encoding@discrete_attribute:json_decoder(),
         gleam_synapses@model@encoding@continuous_attribute:json_decoder()]
    ),
    Attr_json_decoder = decode:map2(
        fun(A, B) -> {f_sharp_attribute_serialized, A, B} end,
        decode:field(<<"Case"/utf8>>, decode:string()),
        decode:field(
            <<"Fields"/utf8>>,
            decode:list(Discr_or_contin_json_decoder)
        )
    ),
    decode:list(Attr_json_decoder).

-spec to_json(
    gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute())
) -> binary().
to_json(Preprocessor) ->
    {ok, Dyn} = gleam_synapses@model@edited_jsone:encode(
        json_encoded(serialized(Preprocessor))
    ),
    {ok, Res} = decode:decode_dynamic(Dyn, decode:string()),
    Res.

-spec of_json(binary()) -> gleam_zlists@interop:z_list(gleam_synapses@model@encoding@serialization:attribute()).
of_json(S) ->
    {ok, Dyn} = gleam_synapses@model@edited_jsone:decode(S),
    {ok, Res} = decode:decode_dynamic(Dyn, json_decoder()),
    lazy_realization(deserialized(Res)).