pedantic

-module(pedantic@encode).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pedantic/encode.gleam").
-export([list/1, optional/1, dict/1, object/1, field/4, build/1, title/2, describe/2, example/2]).
-export_type([encoder/1, object_builder/1]).

-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 encoder(FDP) :: {encoder,
        pedantic@report:type_graph(),
        fun((FDP) -> gleam@dynamic:dynamic_())}.

-opaque object_builder(FDQ) :: {object_builder,
        binary(),
        list(pedantic@report:type_field()),
        fun((FDQ) -> list({binary(), gleam@dynamic:dynamic_()}))}.

-file("src/pedantic/encode.gleam", 47).
?DOC(" List combinator to encode lists to dynamic arrays.\n").
-spec list(encoder(FDT)) -> encoder(list(FDT)).
list(Element_encoder) ->
    Function = fun(Lst) ->
        Encoded_items = gleam@list:map(Lst, erlang:element(3, Element_encoder)),
        gleam_stdlib:identity(Encoded_items)
    end,
    {encoder, {list, erlang:element(2, Element_encoder)}, Function}.

-file("src/pedantic/encode.gleam", 56).
?DOC(" Option/Optional combinator representing absent or nullable values.\n").
-spec optional(encoder(FDX)) -> encoder(gleam@option:option(FDX)).
optional(Inner_encoder) ->
    Function = fun(Opt) -> case Opt of
            {some, V} ->
                (erlang:element(3, Inner_encoder))(V);

            none ->
                gleam@dynamic:nil()
        end end,
    {encoder, {option, erlang:element(2, Inner_encoder)}, Function}.

-file("src/pedantic/encode.gleam", 67).
?DOC(" Dict combinator to encode dictionaries to dynamic objects.\n").
-spec dict(encoder(FEB)) -> encoder(gleam@dict:dict(binary(), FEB)).
dict(Value_encoder) ->
    Function = fun(D) ->
        Entries = begin
            _pipe = maps:to_list(D),
            gleam@list:map(
                _pipe,
                fun(Pair) ->
                    {erlang:element(1, Pair),
                        (erlang:element(3, Value_encoder))(
                            erlang:element(2, Pair)
                        )}
                end
            )
        end,
        maps:from_list(Entries)
    end,
    {encoder, {dict, erlang:element(2, Value_encoder)}, Function}.

-file("src/pedantic/encode.gleam", 78).
?DOC(" Initializes an ObjectBuilder for a custom record constructor.\n").
-spec object(binary()) -> object_builder(any()).
object(Name) ->
    {object_builder, Name, [], fun(_) -> [] end}.

-file("src/pedantic/encode.gleam", 83).
?DOC(" Applies a field description, encoder, and getter to the object builder.\n").
-spec field(object_builder(FEI), binary(), encoder(FEK), fun((FEI) -> FEK)) -> object_builder(FEI).
field(Builder, Name, Field_encoder, Get) ->
    Fields = lists:append(
        erlang:element(3, Builder),
        [{type_field, Name, erlang:element(2, Field_encoder)}]
    ),
    Encoder = fun(Val) ->
        Field_val = Get(Val),
        Encoded_field = (erlang:element(3, Field_encoder))(Field_val),
        lists:append((erlang:element(4, Builder))(Val), [{Name, Encoded_field}])
    end,
    {object_builder, erlang:element(2, Builder), Fields, Encoder}.

-file("src/pedantic/encode.gleam", 102).
?DOC(" Finalizes the ObjectBuilder, converting it into a full Encoder.\n").
-spec build(object_builder(FEN)) -> encoder(FEN).
build(Builder) ->
    Function = fun(Val) ->
        Fields = (erlang:element(4, Builder))(Val),
        maps:from_list(Fields)
    end,
    {encoder,
        {object, erlang:element(2, Builder), erlang:element(3, Builder)},
        Function}.

-file("src/pedantic/encode.gleam", 111).
?DOC(" Sets the title metadata in the AST graph.\n").
-spec title(encoder(FEQ), binary()) -> encoder(FEQ).
title(Encoder, Name) ->
    New_graph = case erlang:element(2, Encoder) of
        {annotated, Inner, Meta} ->
            {annotated,
                Inner,
                {metadata,
                    {some, Name},
                    erlang:element(3, Meta),
                    erlang:element(4, Meta)}};

        Other ->
            {annotated, Other, {metadata, {some, Name}, none, none}}
    end,
    {encoder, New_graph, erlang:element(3, Encoder)}.

-file("src/pedantic/encode.gleam", 125).
?DOC(" Sets the description metadata in the AST graph.\n").
-spec describe(encoder(FET), binary()) -> encoder(FET).
describe(Encoder, Desc) ->
    New_graph = case erlang:element(2, Encoder) of
        {annotated, Inner, Meta} ->
            {annotated,
                Inner,
                {metadata,
                    erlang:element(2, Meta),
                    {some, Desc},
                    erlang:element(4, Meta)}};

        Other ->
            {annotated, Other, {metadata, none, {some, Desc}, none}}
    end,
    {encoder, New_graph, erlang:element(3, Encoder)}.

-file("src/pedantic/encode.gleam", 139).
?DOC(" Sets the example metadata in the AST graph.\n").
-spec example(encoder(FEW), gleam@dynamic:dynamic_()) -> encoder(FEW).
example(Encoder, Ex) ->
    New_graph = case erlang:element(2, Encoder) of
        {annotated, Inner, Meta} ->
            {annotated,
                Inner,
                {metadata,
                    erlang:element(2, Meta),
                    erlang:element(3, Meta),
                    {some, Ex}}};

        Other ->
            {annotated, Other, {metadata, none, none, {some, Ex}}}
    end,
    {encoder, New_graph, erlang:element(3, Encoder)}.