-module(gleam@dynamic).
-compile(no_auto_import).

-export([from/1, unsafe_coerce/1, bit_string/1, string/1, classify/1, int/1, float/1, bool/1, list/1, result/1, typed_result/3, typed_list/2, optional/2, field/2, element/2, tuple2/1, typed_tuple2/3, tuple3/1, typed_tuple3/4, tuple4/1, typed_tuple4/5, tuple5/1, typed_tuple5/6, tuple6/1, typed_tuple6/7, map/1, any/2]).
-export_type([dynamic/0, decode_error/0, unknown_tuple/0]).

-type dynamic() :: any().

-type decode_error() :: {decode_error, binary(), binary()}.

-type unknown_tuple() :: any().

-spec from(any()) -> dynamic().
from(A) ->
    gleam_stdlib:identity(A).

-spec unsafe_coerce(dynamic()) -> any().
unsafe_coerce(A) ->
    gleam_stdlib:identity(A).

-spec bit_string(dynamic()) -> {ok, bitstring()} | {error, decode_error()}.
bit_string(Data) ->
    gleam_stdlib:decode_bit_string(Data).

-spec string(dynamic()) -> {ok, binary()} | {error, decode_error()}.
string(Data) ->
    decode_string(Data).

-spec decode_string(dynamic()) -> {ok, binary()} | {error, decode_error()}.
decode_string(Data) ->
    _pipe = bit_string(Data),
    _pipe@1 = gleam@result:map_error(
        _pipe,
        fun(Error) -> erlang:setelement(2, Error, <<"String"/utf8>>) end
    ),
    gleam@result:then(
        _pipe@1,
        fun(Raw) -> case gleam@bit_string:to_string(Raw) of
                {ok, String} ->
                    {ok, String};

                {error, nil} ->
                    {error,
                     {decode_error, <<"String"/utf8>>, <<"BitString"/utf8>>}}
            end end
    ).

-spec classify(dynamic()) -> binary().
classify(Data) ->
    gleam_stdlib:classify_dynamic(Data).

-spec int(dynamic()) -> {ok, integer()} | {error, decode_error()}.
int(Data) ->
    gleam_stdlib:decode_int(Data).

-spec float(dynamic()) -> {ok, float()} | {error, decode_error()}.
float(Data) ->
    gleam_stdlib:decode_float(Data).

-spec bool(dynamic()) -> {ok, boolean()} | {error, decode_error()}.
bool(Data) ->
    gleam_stdlib:decode_bool(Data).

-spec list(dynamic()) -> {ok, list(dynamic())} | {error, decode_error()}.
list(Value) ->
    gleam_stdlib:decode_list(Value).

-spec result(dynamic()) -> {ok, {ok, dynamic()} | {error, dynamic()}} |
    {error, decode_error()}.
result(Value) ->
    gleam_stdlib:decode_result(Value).

-spec typed_result(
    dynamic(),
    fun((dynamic()) -> {ok, FMP} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FMR} | {error, decode_error()})
) -> {ok, {ok, FMP} | {error, FMR}} | {error, decode_error()}.
typed_result(Dynamic, Decode_ok, Decode_error) ->
    case result(Dynamic) of
        {error, _try} -> {error, _try};
        {ok, Inner_result} ->
            case Inner_result of
                {ok, Raw} ->
                    _pipe = Raw,
                    _pipe@1 = Decode_ok(_pipe),
                    gleam@result:map(_pipe@1, fun(A) -> {ok, A} end);

                {error, Raw@1} ->
                    _pipe@2 = Raw@1,
                    _pipe@3 = Decode_error(_pipe@2),
                    gleam@result:map(_pipe@3, fun(A) -> {error, A} end)
            end
    end.

-spec typed_list(
    dynamic(),
    fun((dynamic()) -> {ok, FMX} | {error, decode_error()})
) -> {ok, list(FMX)} | {error, decode_error()}.
typed_list(Dynamic, Decoder_type) ->
    _pipe = Dynamic,
    _pipe@1 = list(_pipe),
    gleam@result:then(
        _pipe@1,
        fun(_capture) -> gleam@list:try_map(_capture, Decoder_type) end
    ).

-spec optional(
    dynamic(),
    fun((dynamic()) -> {ok, FND} | {error, decode_error()})
) -> {ok, gleam@option:option(FND)} | {error, decode_error()}.
optional(Value, Decode) ->
    gleam_stdlib:decode_option(Value, Decode).

-spec field(dynamic(), any()) -> {ok, dynamic()} | {error, decode_error()}.
field(Value, Name) ->
    gleam_stdlib:decode_field(Value, Name).

-spec element(dynamic(), integer()) -> {ok, dynamic()} | {error, decode_error()}.
element(Data, Index) ->
    case gleam_stdlib:decode_tuple(Data) of
        {error, _try} -> {error, _try};
        {ok, Tuple} ->
            Size = gleam_stdlib:size_of_tuple(Tuple),
            case Index >= 0 of
                true ->
                    case Index < Size of
                        true ->
                            gleam_stdlib:tuple_get(Tuple, Index);

                        false ->
                            at_least_decode_tuple_error(Index + 1, Data)
                    end;

                false ->
                    case gleam@int:absolute_value(Index) =< Size of
                        true ->
                            gleam_stdlib:tuple_get(Tuple, Size + Index);

                        false ->
                            at_least_decode_tuple_error(
                                gleam@int:absolute_value(Index),
                                Data
                            )
                    end
            end
    end.

-spec exact_decode_tuple_error(integer(), dynamic()) -> {ok, any()} |
    {error, decode_error()}.
exact_decode_tuple_error(Size, Data) ->
    S = case Size of
        0 ->
            <<""/utf8>>;

        _@1 ->
            <<"s"/utf8>>
    end,
    _pipe = [<<"Tuple of "/utf8>>,
             gleam@int:to_string(Size),
             <<" element"/utf8>>,
             S],
    _pipe@1 = gleam@string_builder:from_strings(_pipe),
    _pipe@2 = gleam@string_builder:to_string(_pipe@1),
    _pipe@3 = {decode_error, _pipe@2, classify(Data)},
    {error, _pipe@3}.

-spec at_least_decode_tuple_error(integer(), dynamic()) -> {ok, any()} |
    {error, decode_error()}.
at_least_decode_tuple_error(Size, Data) ->
    S = case Size of
        0 ->
            <<""/utf8>>;

        _@1 ->
            <<"s"/utf8>>
    end,
    _pipe = [<<"Tuple of at least "/utf8>>,
             gleam@int:to_string(Size),
             <<" element"/utf8>>,
             S],
    _pipe@1 = gleam@string_builder:from_strings(_pipe),
    _pipe@2 = gleam@string_builder:to_string(_pipe@1),
    _pipe@3 = {decode_error, _pipe@2, classify(Data)},
    {error, _pipe@3}.

-spec tuple2(dynamic()) -> {ok, {dynamic(), dynamic()}} |
    {error, decode_error()}.
tuple2(Value) ->
    case assert_is_tuple(Value, 2) of
        {error, _try} -> {error, _try};
        {ok, _@1} ->
            {ok, unsafe_coerce(Value)}
    end.

-spec assert_is_tuple(dynamic(), integer()) -> {ok, nil} |
    {error, decode_error()}.
assert_is_tuple(Value, Desired_size) ->
    Expected = gleam@string_builder:to_string(
        gleam@string_builder:from_strings(
            [<<"Tuple of "/utf8>>,
             gleam@int:to_string(Desired_size),
             <<" elements"/utf8>>]
        )
    ),
    case put_expected(gleam_stdlib:decode_tuple(Value), Expected) of
        {error, _try} -> {error, _try};
        {ok, Tuple} ->
            case gleam_stdlib:size_of_tuple(Tuple) of
                Size when Size =:= Desired_size ->
                    {ok, nil};

                _@1 ->
                    exact_decode_tuple_error(Desired_size, Value)
            end
    end.

-spec put_expected({ok, FOJ} | {error, decode_error()}, binary()) -> {ok, FOJ} |
    {error, decode_error()}.
put_expected(Result, Expected) ->
    case Result of
        {ok, _@1} ->
            Result;

        {error, E} ->
            {error, erlang:setelement(2, E, Expected)}
    end.

-spec typed_tuple2(
    dynamic(),
    fun((dynamic()) -> {ok, FOO} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FOQ} | {error, decode_error()})
) -> {ok, {FOO, FOQ}} | {error, decode_error()}.
typed_tuple2(Tup, Decode_first, Decode_second) ->
    case tuple2(Tup) of
        {error, _try} -> {error, _try};
        {ok, {First, Second}} ->
            case Decode_first(First) of
                {error, _try@1} -> {error, _try@1};
                {ok, A} ->
                    case Decode_second(Second) of
                        {error, _try@2} -> {error, _try@2};
                        {ok, B} ->
                            {ok, {A, B}}
                    end
            end
    end.

-spec tuple3(dynamic()) -> {ok, {dynamic(), dynamic(), dynamic()}} |
    {error, decode_error()}.
tuple3(Value) ->
    case assert_is_tuple(Value, 3) of
        {error, _try} -> {error, _try};
        {ok, _@1} ->
            {ok, unsafe_coerce(Value)}
    end.

-spec typed_tuple3(
    dynamic(),
    fun((dynamic()) -> {ok, FOW} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FOY} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPA} | {error, decode_error()})
) -> {ok, {FOW, FOY, FPA}} | {error, decode_error()}.
typed_tuple3(Tup, Decode_first, Decode_second, Decode_third) ->
    case tuple3(Tup) of
        {error, _try} -> {error, _try};
        {ok, {First, Second, Third}} ->
            case Decode_first(First) of
                {error, _try@1} -> {error, _try@1};
                {ok, A} ->
                    case Decode_second(Second) of
                        {error, _try@2} -> {error, _try@2};
                        {ok, B} ->
                            case Decode_third(Third) of
                                {error, _try@3} -> {error, _try@3};
                                {ok, C} ->
                                    {ok, {A, B, C}}
                            end
                    end
            end
    end.

-spec tuple4(dynamic()) -> {ok, {dynamic(), dynamic(), dynamic(), dynamic()}} |
    {error, decode_error()}.
tuple4(Value) ->
    case assert_is_tuple(Value, 4) of
        {error, _try} -> {error, _try};
        {ok, _@1} ->
            {ok, unsafe_coerce(Value)}
    end.

-spec typed_tuple4(
    dynamic(),
    fun((dynamic()) -> {ok, FPG} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPI} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPK} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPM} | {error, decode_error()})
) -> {ok, {FPG, FPI, FPK, FPM}} | {error, decode_error()}.
typed_tuple4(Tup, Decode_first, Decode_second, Decode_third, Decode_fourth) ->
    case tuple4(Tup) of
        {error, _try} -> {error, _try};
        {ok, {First, Second, Third, Fourth}} ->
            case Decode_first(First) of
                {error, _try@1} -> {error, _try@1};
                {ok, A} ->
                    case Decode_second(Second) of
                        {error, _try@2} -> {error, _try@2};
                        {ok, B} ->
                            case Decode_third(Third) of
                                {error, _try@3} -> {error, _try@3};
                                {ok, C} ->
                                    case Decode_fourth(Fourth) of
                                        {error, _try@4} -> {error, _try@4};
                                        {ok, D} ->
                                            {ok, {A, B, C, D}}
                                    end
                            end
                    end
            end
    end.

-spec tuple5(dynamic()) -> {ok,
                            {dynamic(),
                             dynamic(),
                             dynamic(),
                             dynamic(),
                             dynamic()}} |
    {error, decode_error()}.
tuple5(Value) ->
    case assert_is_tuple(Value, 5) of
        {error, _try} -> {error, _try};
        {ok, _@1} ->
            {ok, unsafe_coerce(Value)}
    end.

-spec typed_tuple5(
    dynamic(),
    fun((dynamic()) -> {ok, FPS} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPU} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPW} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FPY} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQA} | {error, decode_error()})
) -> {ok, {FPS, FPU, FPW, FPY, FQA}} | {error, decode_error()}.
typed_tuple5(
    Tup,
    Decode_first,
    Decode_second,
    Decode_third,
    Decode_fourth,
    Decode_fifth
) ->
    case tuple5(Tup) of
        {error, _try} -> {error, _try};
        {ok, {First, Second, Third, Fourth, Fifth}} ->
            case Decode_first(First) of
                {error, _try@1} -> {error, _try@1};
                {ok, A} ->
                    case Decode_second(Second) of
                        {error, _try@2} -> {error, _try@2};
                        {ok, B} ->
                            case Decode_third(Third) of
                                {error, _try@3} -> {error, _try@3};
                                {ok, C} ->
                                    case Decode_fourth(Fourth) of
                                        {error, _try@4} -> {error, _try@4};
                                        {ok, D} ->
                                            case Decode_fifth(Fifth) of
                                                {error, _try@5} -> {error, _try@5};
                                                {ok, E} ->
                                                    {ok, {A, B, C, D, E}}
                                            end
                                    end
                            end
                    end
            end
    end.

-spec tuple6(dynamic()) -> {ok,
                            {dynamic(),
                             dynamic(),
                             dynamic(),
                             dynamic(),
                             dynamic(),
                             dynamic()}} |
    {error, decode_error()}.
tuple6(Value) ->
    case assert_is_tuple(Value, 6) of
        {error, _try} -> {error, _try};
        {ok, _@1} ->
            {ok, unsafe_coerce(Value)}
    end.

-spec typed_tuple6(
    dynamic(),
    fun((dynamic()) -> {ok, FQG} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQI} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQK} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQM} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQO} | {error, decode_error()}),
    fun((dynamic()) -> {ok, FQQ} | {error, decode_error()})
) -> {ok, {FQG, FQI, FQK, FQM, FQO, FQQ}} | {error, decode_error()}.
typed_tuple6(
    Tup,
    Decode_first,
    Decode_second,
    Decode_third,
    Decode_fourth,
    Decode_fifth,
    Decode_sixth
) ->
    case tuple6(Tup) of
        {error, _try} -> {error, _try};
        {ok, {First, Second, Third, Fourth, Fifth, Sixth}} ->
            case Decode_first(First) of
                {error, _try@1} -> {error, _try@1};
                {ok, A} ->
                    case Decode_second(Second) of
                        {error, _try@2} -> {error, _try@2};
                        {ok, B} ->
                            case Decode_third(Third) of
                                {error, _try@3} -> {error, _try@3};
                                {ok, C} ->
                                    case Decode_fourth(Fourth) of
                                        {error, _try@4} -> {error, _try@4};
                                        {ok, D} ->
                                            case Decode_fifth(Fifth) of
                                                {error, _try@5} -> {error, _try@5};
                                                {ok, E} ->
                                                    case Decode_sixth(Sixth) of
                                                        {error, _try@6} -> {error, _try@6};
                                                        {ok, F} ->
                                                            {ok,
                                                             {A, B, C, D, E, F}}
                                                    end
                                            end
                                    end
                            end
                    end
            end
    end.

-spec map(dynamic()) -> {ok, gleam@map:map_(dynamic(), dynamic())} |
    {error, decode_error()}.
map(Value) ->
    gleam_stdlib:decode_map(Value).

-spec any(
    dynamic(),
    list(fun((dynamic()) -> {ok, FRC} | {error, decode_error()}))
) -> {ok, FRC} | {error, decode_error()}.
any(Data, Decoders) ->
    _pipe = Decoders,
    _pipe@1 = gleam@list:find_map(_pipe, fun(Decoder) -> Decoder(Data) end),
    gleam@result:map_error(
        _pipe@1,
        fun(_) -> {decode_error, <<"unknown"/utf8>>, <<"unknown"/utf8>>} end
    ).