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

-export([object/1, success/1, string/0, bool/0, float/0, int/0, null/0, list/1, result/2, field/4, optional/1, dict/2, enum/2, map/4, encode/1, decode/1, type_def/1]).
-export_type([glitr_type/0, glitr_value/0, converter/1, partial_converter/1]).

-type glitr_type() :: string |
    bool |
    float |
    int |
    null |
    {list, glitr_type()} |
    {dict, glitr_type(), glitr_type()} |
    {object, list({binary(), glitr_type()})} |
    {optional, glitr_type()} |
    {result, glitr_type(), glitr_type()} |
    {enum, list({binary(), glitr_type()})}.

-type glitr_value() :: {string_value, binary()} |
    {bool_value, boolean()} |
    {float_value, float()} |
    {int_value, integer()} |
    null_value |
    {list_value, list(glitr_value())} |
    {dict_value, gleam@dict:dict(glitr_value(), glitr_value())} |
    {object_value, list({binary(), glitr_value()})} |
    {optional_value, gleam@option:option(glitr_value())} |
    {result_value, {ok, glitr_value()} | {error, glitr_value()}} |
    {enum_value, binary(), glitr_value()}.

-opaque converter(FUK) :: {converter,
        fun((FUK) -> glitr_value()),
        fun((glitr_value()) -> {ok, FUK} |
            {error, list(gleam@dynamic:decode_error())}),
        glitr_type(),
        FUK}.

-opaque partial_converter(FUL) :: {partial_converter,
        fun((FUL) -> glitr_value()),
        fun((glitr_value()) -> {ok, FUL} |
            {error, list(gleam@dynamic:decode_error())}),
        list({binary(), glitr_type()}),
        {ok, FUL} | {error, list(gleam@dynamic:decode_error())}}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 80).
-spec object(partial_converter(FUM)) -> converter(FUM).
object(Converter) ->
    _assert_subject = erlang:element(5, Converter),
    {ok, Default_value} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"convert"/utf8>>,
                        function => <<"object"/utf8>>,
                        line => 81})
    end,
    {converter,
        erlang:element(2, Converter),
        erlang:element(3, Converter),
        {object, erlang:element(4, Converter)},
        Default_value}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 153).
-spec success(FUW) -> partial_converter(FUW).
success(C) ->
    {partial_converter,
        fun(_) -> {object_value, []} end,
        fun(_) -> {ok, C} end,
        [],
        {ok, C}}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 489).
-spec get_type(glitr_value()) -> binary().
get_type(Val) ->
    case Val of
        {bool_value, _} ->
            <<"BoolValue"/utf8>>;

        {dict_value, _} ->
            <<"DictValue"/utf8>>;

        {enum_value, _, _} ->
            <<"EnumValue"/utf8>>;

        {float_value, _} ->
            <<"FloatValue"/utf8>>;

        {int_value, _} ->
            <<"IntValue"/utf8>>;

        {list_value, _} ->
            <<"ListValue"/utf8>>;

        null_value ->
            <<"NullValue"/utf8>>;

        {object_value, _} ->
            <<"ObjectValue"/utf8>>;

        {optional_value, _} ->
            <<"OptionalValue"/utf8>>;

        {result_value, _} ->
            <<"ResultValue"/utf8>>;

        {string_value, _} ->
            <<"StringValue"/utf8>>
    end.

-file("/home/runner/work/convert/convert/src/convert.gleam", 158).
-spec string() -> converter(binary()).
string() ->
    {converter, fun(V) -> {string_value, V} end, fun(V@1) -> case V@1 of
                {string_value, Val} ->
                    {ok, Val};

                Other ->
                    {error,
                        [{decode_error,
                                <<"StringValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end, string, <<""/utf8>>}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 174).
-spec bool() -> converter(boolean()).
bool() ->
    {converter, fun(V) -> {bool_value, V} end, fun(V@1) -> case V@1 of
                {bool_value, Val} ->
                    {ok, Val};

                Other ->
                    {error,
                        [{decode_error,
                                <<"BoolValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end, bool, false}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 189).
-spec float() -> converter(float()).
float() ->
    {converter, fun(V) -> {float_value, V} end, fun(V@1) -> case V@1 of
                {float_value, Val} ->
                    {ok, Val};

                Other ->
                    {error,
                        [{decode_error,
                                <<"FloatValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end, float, +0.0}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 204).
-spec int() -> converter(integer()).
int() ->
    {converter, fun(V) -> {int_value, V} end, fun(V@1) -> case V@1 of
                {int_value, Val} ->
                    {ok, Val};

                Other ->
                    {error,
                        [{decode_error,
                                <<"IntValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end, int, 0}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 219).
-spec null() -> converter(nil).
null() ->
    {converter, fun(_) -> null_value end, fun(V) -> case V of
                null_value ->
                    {ok, nil};

                Other ->
                    {error,
                        [{decode_error,
                                <<"NullValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end, null, nil}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 236).
-spec list(converter(FVD)) -> converter(list(FVD)).
list(Of) ->
    {converter,
        fun(V) ->
            {list_value,
                begin
                    _pipe = V,
                    gleam@list:map(_pipe, erlang:element(2, Of))
                end}
        end,
        fun(V@1) -> case V@1 of
                {list_value, Vals} ->
                    _pipe@1 = Vals,
                    gleam@list:fold(
                        _pipe@1,
                        {ok, []},
                        fun(Result, Val) ->
                            case {Result, (erlang:element(3, Of))(Val)} of
                                {{ok, Res}, {ok, New_res}} ->
                                    {ok, lists:append(Res, [New_res])};

                                {{error, Errs}, {error, New_errs}} ->
                                    {error, lists:append(Errs, New_errs)};

                                {_, {error, Errs@1}} ->
                                    {error, Errs@1};

                                {{error, Errs@1}, _} ->
                                    {error, Errs@1}
                            end
                        end
                    );

                Other ->
                    {error,
                        [{decode_error,
                                <<"ListValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end,
        {list, erlang:element(4, Of)},
        []}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 282).
-spec result(converter(FVL), converter(FVN)) -> converter({ok, FVL} |
    {error, FVN}).
result(Res, Error) ->
    {converter,
        fun(V) ->
            {result_value,
                begin
                    _pipe = V,
                    _pipe@1 = gleam@result:map(_pipe, erlang:element(2, Res)),
                    gleam@result:map_error(_pipe@1, erlang:element(2, Error))
                end}
        end,
        fun(V@1) -> case V@1 of
                {result_value, {ok, Val}} ->
                    _pipe@2 = Val,
                    _pipe@3 = (erlang:element(3, Res))(_pipe@2),
                    gleam@result:map(_pipe@3, fun(Field@0) -> {ok, Field@0} end);

                {result_value, {error, Val@1}} ->
                    _pipe@4 = Val@1,
                    _pipe@5 = (erlang:element(3, Error))(_pipe@4),
                    gleam@result:map(
                        _pipe@5,
                        fun(Field@0) -> {error, Field@0} end
                    );

                Other ->
                    {error,
                        [{decode_error,
                                <<"ResultValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end,
        {result, erlang:element(4, Res), erlang:element(4, Error)},
        {ok, erlang:element(5, Res)}}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 97).
-spec field(
    binary(),
    fun((FUP) -> {ok, FUQ} | {error, nil}),
    converter(FUQ),
    fun((FUQ) -> partial_converter(FUP))
) -> partial_converter(FUP).
field(Field_name, Field_getter, Field_type, Next) ->
    {partial_converter,
        fun(Base) ->
            Value = Field_getter(Base),
            case Value of
                {error, nil} ->
                    null_value;

                {ok, Field_value} ->
                    Converter = Next(Field_value),
                    case (erlang:element(2, Converter))(Base) of
                        {object_value, Fields} ->
                            {object_value,
                                [{Field_name,
                                        (erlang:element(2, Field_type))(
                                            Field_value
                                        )} |
                                    Fields]};

                        _ ->
                            null_value
                    end
            end
        end,
        fun(V) -> case V of
                {object_value, Values} ->
                    Field_value@1 = begin
                        _pipe = Values,
                        _pipe@1 = gleam@list:key_find(_pipe, Field_name),
                        _pipe@2 = gleam@result:replace_error(
                            _pipe@1,
                            [{decode_error,
                                    <<"Value"/utf8>>,
                                    <<"None"/utf8>>,
                                    [Field_name]}]
                        ),
                        gleam@result:then(
                            _pipe@2,
                            erlang:element(3, Field_type)
                        )
                    end,
                    gleam@result:'try'(
                        Field_value@1,
                        fun(A) -> (erlang:element(3, Next(A)))(V) end
                    );

                _ ->
                    {error, []}
            end end,
        ([{Field_name, erlang:element(4, Field_type)} |
            erlang:element(4, Next(erlang:element(5, Field_type)))]),
        (erlang:element(5, Next(erlang:element(5, Field_type))))}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 261).
-spec optional(converter(FVH)) -> converter(gleam@option:option(FVH)).
optional(Of) ->
    {converter,
        fun(V) ->
            {optional_value,
                begin
                    _pipe = V,
                    gleam@option:map(_pipe, erlang:element(2, Of))
                end}
        end,
        fun(V@1) -> case V@1 of
                {optional_value, none} ->
                    {ok, none};

                {optional_value, {some, Val}} ->
                    _pipe@1 = Val,
                    _pipe@2 = (erlang:element(3, Of))(_pipe@1),
                    gleam@result:map(
                        _pipe@2,
                        fun(Field@0) -> {some, Field@0} end
                    );

                Other ->
                    {error,
                        [{decode_error,
                                <<"OptionalValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end,
        {optional, erlang:element(4, Of)},
        none}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 314).
-spec dict(converter(FVS), converter(FVU)) -> converter(gleam@dict:dict(FVS, FVU)).
dict(Key, Value) ->
    {converter,
        fun(V) ->
            {dict_value,
                begin
                    _pipe = V,
                    _pipe@1 = maps:to_list(_pipe),
                    _pipe@4 = gleam@list:map(
                        _pipe@1,
                        fun(Kv) ->
                            {begin
                                    _pipe@2 = erlang:element(1, Kv),
                                    (erlang:element(2, Key))(_pipe@2)
                                end,
                                begin
                                    _pipe@3 = erlang:element(2, Kv),
                                    (erlang:element(2, Value))(_pipe@3)
                                end}
                        end
                    ),
                    maps:from_list(_pipe@4)
                end}
        end,
        fun(V@1) -> case V@1 of
                {dict_value, D} ->
                    _pipe@5 = D,
                    _pipe@6 = maps:to_list(_pipe@5),
                    _pipe@7 = gleam@list:fold(
                        _pipe@6,
                        {ok, []},
                        fun(Result, Kv@1) ->
                            case {Result,
                                (erlang:element(3, Key))(
                                    erlang:element(1, Kv@1)
                                ),
                                (erlang:element(3, Value))(
                                    erlang:element(2, Kv@1)
                                )} of
                                {{ok, Values}, {ok, New_k}, {ok, New_v}} ->
                                    {ok, lists:append(Values, [{New_k, New_v}])};

                                {{error, Errs}, {ok, _}, {ok, _}} ->
                                    {error, Errs};

                                {{ok, _}, {ok, _}, {error, Errs}} ->
                                    {error, Errs};

                                {{ok, _}, {error, Errs}, {ok, _}} ->
                                    {error, Errs};

                                {{ok, _}, {error, Errs_1}, {error, Errs_2}} ->
                                    {error, lists:append(Errs_1, Errs_2)};

                                {{error, Errs_1}, {error, Errs_2}, {ok, _}} ->
                                    {error, lists:append(Errs_1, Errs_2)};

                                {{error, Errs_1}, {ok, _}, {error, Errs_2}} ->
                                    {error, lists:append(Errs_1, Errs_2)};

                                {{error, Errs@1},
                                    {error, Errs_k},
                                    {error, Errs_v}} ->
                                    {error,
                                        gleam@list:concat(
                                            [Errs@1, Errs_k, Errs_v]
                                        )}
                            end
                        end
                    ),
                    gleam@result:map(_pipe@7, fun maps:from_list/1);

                Other ->
                    {error,
                        [{decode_error,
                                <<"DictValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end,
        {dict, erlang:element(4, Key), erlang:element(4, Value)},
        maps:new()}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 402).
-spec enum(fun((FVZ) -> binary()), list({binary(), converter(FVZ)})) -> converter(FVZ).
enum(Tags, Converters) ->
    {converter,
        fun(V) ->
            Tag = Tags(V),
            case begin
                _pipe = Converters,
                gleam@list:key_find(_pipe, Tag)
            end of
                {ok, Variant} ->
                    {enum_value, Tag, (erlang:element(2, Variant))(V)};

                {error, _} ->
                    null_value
            end
        end,
        fun(V@1) -> case V@1 of
                {enum_value, Variant_name, Value} ->
                    gleam@result:'try'(
                        begin
                            _pipe@1 = Converters,
                            _pipe@2 = gleam@list:key_find(_pipe@1, Variant_name),
                            gleam@result:replace_error(
                                _pipe@2,
                                [{decode_error,
                                        <<"One of: "/utf8,
                                            (begin
                                                _pipe@3 = Converters,
                                                _pipe@4 = gleam@list:map(
                                                    _pipe@3,
                                                    fun(V@2) ->
                                                        erlang:element(1, V@2)
                                                    end
                                                ),
                                                gleam@string:join(
                                                    _pipe@4,
                                                    <<"/"/utf8>>
                                                )
                                            end)/binary>>,
                                        Variant_name,
                                        [<<"0"/utf8>>]}]
                            )
                        end,
                        fun(Variant@1) ->
                            (erlang:element(3, Variant@1))(Value)
                        end
                    );

                Other ->
                    {error,
                        [{decode_error,
                                <<"EnumValue"/utf8>>,
                                get_type(Other),
                                []}]}
            end end,
        {enum,
            begin
                _pipe@5 = Converters,
                gleam@list:map(
                    _pipe@5,
                    fun(Var) ->
                        {erlang:element(1, Var),
                            erlang:element(4, (erlang:element(2, Var)))}
                    end
                )
            end},
        begin
            [First | _] = case Converters of
                [_ | _] -> Converters;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                value => _assert_fail,
                                module => <<"convert"/utf8>>,
                                function => <<"enum"/utf8>>,
                                line => 437})
            end,
            erlang:element(5, (erlang:element(2, First)))
        end}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 468).
-spec map(
    converter(FWD),
    fun((FWF) -> FWD),
    fun((FWD) -> {ok, FWF} | {error, list(gleam@dynamic:decode_error())}),
    FWF
) -> converter(FWF).
map(Converter, Encode_map, Decode_map, Default_value) ->
    {converter,
        fun(V) ->
            A_value = Encode_map(V),
            (erlang:element(2, Converter))(A_value)
        end,
        fun(V@1) -> _pipe = (erlang:element(3, Converter))(V@1),
            gleam@result:then(_pipe, Decode_map) end,
        erlang:element(4, Converter),
        Default_value}.

-file("/home/runner/work/convert/convert/src/convert.gleam", 507).
-spec encode(converter(FWK)) -> fun((FWK) -> glitr_value()).
encode(Converter) ->
    erlang:element(2, Converter).

-file("/home/runner/work/convert/convert/src/convert.gleam", 512).
-spec decode(converter(FWM)) -> fun((glitr_value()) -> {ok, FWM} |
    {error, list(gleam@dynamic:decode_error())}).
decode(Converter) ->
    erlang:element(3, Converter).

-file("/home/runner/work/convert/convert/src/convert.gleam", 519).
-spec type_def(converter(any())) -> glitr_type().
type_def(Converter) ->
    erlang:element(4, Converter).