-module(decode@zero).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([run/2, success/1, decode_dynamic/1, map/2, map_errors/2, then/2, one_of/2, new_primitive_decoder/2, decode_error/2, decode_string/1, decode_bool/1, decode_int/1, decode_float/1, decode_bit_array/1, optional/1, collapse_errors/2, failure/2, dict/2, list/1, subfield/3, at/2, field/3]).
-export_type([decoder/1]).

-opaque decoder(GBP) :: {decoder,
        fun((gleam@dynamic:dynamic_()) -> {GBP,
            list(gleam@dynamic:decode_error())})}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 329).
-spec run(gleam@dynamic:dynamic_(), decoder(GBX)) -> {ok, GBX} |
    {error, list(gleam@dynamic:decode_error())}.
run(Data, Decoder) ->
    {Maybe_invalid_data, Errors} = (erlang:element(2, Decoder))(Data),
    case Errors of
        [] ->
            {ok, Maybe_invalid_data};

        _ ->
            {error, Errors}
    end.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 448).
-spec success(GCV) -> decoder(GCV).
success(Data) ->
    {decoder, fun(_) -> {Data, []} end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 500).
-spec run_dynamic_function(
    gleam@dynamic:dynamic_(),
    GDE,
    fun((gleam@dynamic:dynamic_()) -> {ok, GDE} |
        {error, list(gleam@dynamic:decode_error())})
) -> {GDE, list(gleam@dynamic:decode_error())}.
run_dynamic_function(Data, Zero, F) ->
    case F(Data) of
        {ok, Data@1} ->
            {Data@1, []};

        {error, Errors} ->
            {Zero, Errors}
    end.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 582).
-spec decode_dynamic(gleam@dynamic:dynamic_()) -> {gleam@dynamic:dynamic_(),
    list(gleam@dynamic:decode_error())}.
decode_dynamic(Data) ->
    {Data, []}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 736).
-spec map(decoder(GEY), fun((GEY) -> GFA)) -> decoder(GFA).
map(Decoder, Transformer) ->
    {decoder,
        fun(D) ->
            {Data, Errors} = (erlang:element(2, Decoder))(D),
            {Transformer(Data), Errors}
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 745).
-spec map_errors(
    decoder(GFC),
    fun((list(gleam@dynamic:decode_error())) -> list(gleam@dynamic:decode_error()))
) -> decoder(GFC).
map_errors(Decoder, Transformer) ->
    {decoder,
        fun(D) ->
            {Data, Errors} = (erlang:element(2, Decoder))(D),
            {Data, Transformer(Errors)}
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 783).
-spec then(decoder(GFK), fun((GFK) -> decoder(GFM))) -> decoder(GFM).
then(Decoder, Next) ->
    {decoder,
        fun(Dynamic_data) ->
            {Data, Errors} = (erlang:element(2, Decoder))(Dynamic_data),
            Decoder@1 = Next(Data),
            {Data@1, _} = Layer = (erlang:element(2, Decoder@1))(Dynamic_data),
            case Errors of
                [] ->
                    Layer;

                _ ->
                    {Data@1, Errors}
            end
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 826).
-spec run_decoders(
    gleam@dynamic:dynamic_(),
    {GFU, list(gleam@dynamic:decode_error())},
    list(decoder(GFU))
) -> {GFU, list(gleam@dynamic:decode_error())}.
run_decoders(Data, Failure, Decoders) ->
    case Decoders of
        [] ->
            Failure;

        [Decoder | Decoders@1] ->
            {_, Errors} = Layer = (erlang:element(2, Decoder))(Data),
            case Errors of
                [] ->
                    Layer;

                _ ->
                    run_decoders(Data, Failure, Decoders@1)
            end
    end.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 813).
-spec one_of(decoder(GFP), list(decoder(GFP))) -> decoder(GFP).
one_of(First, Alternatives) ->
    {decoder,
        fun(Dynamic_data) ->
            {_, Errors} = Layer = (erlang:element(2, First))(Dynamic_data),
            case Errors of
                [] ->
                    Layer;

                _ ->
                    run_decoders(Dynamic_data, Layer, Alternatives)
            end
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 873).
-spec new_primitive_decoder(
    fun((gleam@dynamic:dynamic_()) -> {ok, GGB} |
        {error, list(gleam@dynamic:decode_error())}),
    GGB
) -> decoder(GGB).
new_primitive_decoder(Decoding_function, Zero) ->
    {decoder, fun(D) -> case Decoding_function(D) of
                {ok, T} ->
                    {T, []};

                {error, Errors} ->
                    {Zero, Errors}
            end end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 454).
-spec decode_error(binary(), gleam@dynamic:dynamic_()) -> list(gleam@dynamic:decode_error()).
decode_error(Expected, Found) ->
    [{decode_error, Expected, gleam@dynamic:classify(Found), []}].

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 522).
-spec decode_string(gleam@dynamic:dynamic_()) -> {binary(),
    list(gleam@dynamic:decode_error())}.
decode_string(Data) ->
    run_dynamic_function(Data, <<""/utf8>>, fun gleam@dynamic:string/1).

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 537).
-spec decode_bool(gleam@dynamic:dynamic_()) -> {boolean(),
    list(gleam@dynamic:decode_error())}.
decode_bool(Data) ->
    run_dynamic_function(Data, false, fun gleam@dynamic:bool/1).

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 552).
-spec decode_int(gleam@dynamic:dynamic_()) -> {integer(),
    list(gleam@dynamic:decode_error())}.
decode_int(Data) ->
    run_dynamic_function(Data, 0, fun gleam@dynamic:int/1).

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 567).
-spec decode_float(gleam@dynamic:dynamic_()) -> {float(),
    list(gleam@dynamic:decode_error())}.
decode_float(Data) ->
    run_dynamic_function(Data, +0.0, fun gleam@dynamic:float/1).

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 597).
-spec decode_bit_array(gleam@dynamic:dynamic_()) -> {bitstring(),
    list(gleam@dynamic:decode_error())}.
decode_bit_array(Data) ->
    run_dynamic_function(Data, <<>>, fun gleam@dynamic:bit_array/1).

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 710).
-spec optional(decoder(GEU)) -> decoder(gleam@option:option(GEU)).
optional(Inner) ->
    {decoder,
        fun(Data) ->
            case (gleam@dynamic:optional(fun(Field@0) -> {ok, Field@0} end))(
                Data
            ) of
                {ok, none} ->
                    {none, []};

                {ok, {some, Data@1}} ->
                    {Data@2, Errors} = (erlang:element(2, Inner))(Data@1),
                    {{some, Data@2}, Errors};

                {error, _} ->
                    {Data@3, Errors@1} = (erlang:element(2, Inner))(Data),
                    {{some, Data@3}, Errors@1}
            end
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 769).
-spec collapse_errors(decoder(GFH), binary()) -> decoder(GFH).
collapse_errors(Decoder, Name) ->
    {decoder,
        fun(Dynamic_data) ->
            {Data, Errors} = Layer = (erlang:element(2, Decoder))(Dynamic_data),
            case Errors of
                [] ->
                    Layer;

                _ ->
                    {Data, decode_error(Name, Dynamic_data)}
            end
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 847).
-spec failure(GFZ, binary()) -> decoder(GFZ).
failure(Zero, Expected) ->
    {decoder, fun(D) -> {Zero, decode_error(Expected, D)} end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 664).
-spec fold_dict(
    {gleam@dict:dict(GEG, GEH), list(gleam@dynamic:decode_error())},
    gleam@dynamic:dynamic_(),
    gleam@dynamic:dynamic_(),
    fun((gleam@dynamic:dynamic_()) -> {GEG, list(gleam@dynamic:decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {GEH, list(gleam@dynamic:decode_error())})
) -> {gleam@dict:dict(GEG, GEH), list(gleam@dynamic:decode_error())}.
fold_dict(Acc, Key, Value, Key_decoder, Value_decoder) ->
    case Key_decoder(Key) of
        {Key@1, []} ->
            case Value_decoder(Value) of
                {Value@1, []} ->
                    Dict = gleam@dict:insert(
                        erlang:element(1, Acc),
                        Key@1,
                        Value@1
                    ),
                    {Dict, erlang:element(2, Acc)};

                {_, Errors} ->
                    push_path({gleam@dict:new(), Errors}, [<<"values"/utf8>>])
            end;

        {_, Errors@1} ->
            push_path({gleam@dict:new(), Errors@1}, [<<"keys"/utf8>>])
    end.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 644).
-spec dict(decoder(GDZ), decoder(GEB)) -> decoder(gleam@dict:dict(GDZ, GEB)).
dict(Key, Value) ->
    {decoder, fun(Data) -> case decode_ffi:dict(Data) of
                {error, _} ->
                    {gleam@dict:new(), decode_error(<<"Dict"/utf8>>, Data)};

                {ok, Dict} ->
                    gleam@dict:fold(
                        Dict,
                        {gleam@dict:new(), []},
                        fun(A, K, V) -> case erlang:element(2, A) of
                                [] ->
                                    fold_dict(
                                        A,
                                        K,
                                        V,
                                        erlang:element(2, Key),
                                        erlang:element(2, Value)
                                    );

                                _ ->
                                    A
                            end end
                    )
            end end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 612).
-spec list(decoder(GDN)) -> decoder(list(GDN)).
list(Inner) ->
    {decoder,
        fun(Data) ->
            decode_ffi:list(
                Data,
                erlang:element(2, Inner),
                fun(P, K) -> push_path(P, [K]) end,
                0,
                []
            )
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 404).
-spec push_path({GCQ, list(gleam@dynamic:decode_error())}, list(any())) -> {GCQ,
    list(gleam@dynamic:decode_error())}.
push_path(Layer, Path) ->
    Decoder = gleam@dynamic:any(
        [fun gleam@dynamic:string/1,
            fun(X) ->
                gleam@result:map(
                    gleam@dynamic:int(X),
                    fun gleam@int:to_string/1
                )
            end]
    ),
    Path@1 = gleam@list:map(
        Path,
        fun(Key) ->
            Key@1 = gleam@dynamic:from(Key),
            case Decoder(Key@1) of
                {ok, Key@2} ->
                    Key@2;

                {error, _} ->
                    <<<<"<"/utf8, (gleam@dynamic:classify(Key@1))/binary>>/binary,
                        ">"/utf8>>
            end
        end
    ),
    Errors = gleam@list:map(
        erlang:element(2, Layer),
        fun(Error) ->
            erlang:setelement(
                4,
                Error,
                lists:append(Path@1, erlang:element(4, Error))
            )
        end
    ),
    {erlang:element(1, Layer), Errors}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 373).
-spec index(
    list(GCH),
    list(GCH),
    fun((gleam@dynamic:dynamic_()) -> {GCK, list(gleam@dynamic:decode_error())}),
    gleam@dynamic:dynamic_()
) -> {GCK, list(gleam@dynamic:decode_error())}.
index(Path, Position, Inner, Data) ->
    case Path of
        [] ->
            _pipe = Inner(Data),
            push_path(_pipe, lists:reverse(Position));

        [Key | Path@1] ->
            case decode_ffi:index(Data, Key) of
                {ok, Data@1} ->
                    index(Path@1, [Key | Position], Inner, Data@1);

                {error, Kind} ->
                    {Default, _} = Inner(Data),
                    _pipe@1 = {Default,
                        [{decode_error, Kind, gleam@dynamic:classify(Data), []}]},
                    push_path(_pipe@1, lists:reverse(Position))
            end
    end.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 302).
-spec subfield(list(any()), decoder(GBS), fun((GBS) -> decoder(GBU))) -> decoder(GBU).
subfield(Field_path, Field_decoder, Next) ->
    {decoder,
        fun(Data) ->
            {Out, Errors1} = index(
                Field_path,
                [],
                erlang:element(2, Field_decoder),
                Data
            ),
            {Out@1, Errors2} = (erlang:element(2, Next(Out)))(Data),
            {Out@1, lists:append(Errors1, Errors2)}
        end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 369).
-spec at(list(any()), decoder(GCE)) -> decoder(GCE).
at(Path, Inner) ->
    {decoder, fun(Data) -> index(Path, [], erlang:element(2, Inner), Data) end}.

-file("/Users/louis/src/gleam/decode/src/decode/zero.gleam", 492).
-spec field(any(), decoder(GCZ), fun((GCZ) -> decoder(GDB))) -> decoder(GDB).
field(Field_name, Field_decoder, Next) ->
    subfield([Field_name], Field_decoder, Next).