clad

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

-export([decoded/1, string/3, int/3, float/3, string_with_default/4, int_with_default/4, float_with_default/4, bool/3, bool_with_default/4, decode/2]).

-spec decoded(FZI) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZI} |
    {error, list(gleam@dynamic:decode_error())}).
decoded(Value) ->
    fun(_) -> {ok, Value} end.

-spec with_default(
    fun((gleam@dynamic:dynamic_()) -> {ok, FZX} |
        {error, list(gleam@dynamic:decode_error())}),
    FZX
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZX} |
    {error, list(gleam@dynamic:decode_error())}).
with_default(Decoder, Default) ->
    fun(Data) -> case Decoder(Data) of
            {ok, Decoded} ->
                {ok, Decoded};

            {error, [{decode_error, <<"field"/utf8>>, <<"nothing"/utf8>>, [_]}]} ->
                {ok, Default};

            Errors ->
                Errors
        end end.

-spec do_long_name(
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, GAA} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, GAA} |
    {error, list(gleam@dynamic:decode_error())}).
do_long_name(Long_name, Decoder) ->
    gleam@dynamic:field(<<"--"/utf8, Long_name/binary>>, Decoder).

-spec do_short_name(
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, GAD} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, GAD} |
    {error, list(gleam@dynamic:decode_error())}).
do_short_name(Short_name, Decoder) ->
    gleam@dynamic:field(<<"-"/utf8, Short_name/binary>>, Decoder).

-spec do_flag(
    binary(),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FZU} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZU} |
    {error, list(gleam@dynamic:decode_error())}).
do_flag(Long_name, Short_name, Decoder) ->
    fun(Data) -> case (do_long_name(Long_name, Decoder))(Data) of
            {ok, Decoded} ->
                {ok, Decoded};

            {error,
                [{decode_error, <<"field"/utf8>>, <<"nothing"/utf8>>, [_]}] = Errors} ->
                case (do_short_name(Short_name, Decoder))(Data) of
                    {ok, Decoded@1} ->
                        {ok, Decoded@1};

                    {error,
                        [{decode_error,
                                <<"field"/utf8>>,
                                <<"nothing"/utf8>>,
                                [_]}]} ->
                        {error, Errors};

                    Other ->
                        Other
                end;

            Error ->
                Error
        end end.

-spec flag(
    binary(),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FZK} |
        {error, list(gleam@dynamic:decode_error())}),
    fun((FZK) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZM} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZM} |
    {error, list(gleam@dynamic:decode_error())}).
flag(Long_name, Short_name, Decoder, Next) ->
    fun(Data) ->
        First = do_flag(Long_name, Short_name, Decoder),
        gleam@result:'try'(First(Data), fun(A) -> (Next(A))(Data) end)
    end.

-spec string(
    binary(),
    binary(),
    fun((binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYK} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYK} |
    {error, list(gleam@dynamic:decode_error())}).
string(Long_name, Short_name, Next) ->
    flag(Long_name, Short_name, fun gleam@dynamic:string/1, Next).

-spec int(
    binary(),
    binary(),
    fun((integer()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYQ} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYQ} |
    {error, list(gleam@dynamic:decode_error())}).
int(Long_name, Short_name, Next) ->
    flag(Long_name, Short_name, fun gleam@dynamic:int/1, Next).

-spec float(
    binary(),
    binary(),
    fun((float()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYW} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYW} |
    {error, list(gleam@dynamic:decode_error())}).
float(Long_name, Short_name, Next) ->
    flag(Long_name, Short_name, fun gleam@dynamic:float/1, Next).

-spec flag_with_default(
    binary(),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FZP} |
        {error, list(gleam@dynamic:decode_error())}),
    FZP,
    fun((FZP) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZR} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZR} |
    {error, list(gleam@dynamic:decode_error())}).
flag_with_default(Long_name, Short_name, Decoder, Default, Next) ->
    fun(Data) ->
        First = begin
            _pipe = do_flag(Long_name, Short_name, Decoder),
            with_default(_pipe, Default)
        end,
        gleam@result:'try'(First(Data), fun(A) -> (Next(A))(Data) end)
    end.

-spec string_with_default(
    binary(),
    binary(),
    binary(),
    fun((binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYN} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYN} |
    {error, list(gleam@dynamic:decode_error())}).
string_with_default(Long_name, Short_name, Default, Next) ->
    flag_with_default(
        Long_name,
        Short_name,
        fun gleam@dynamic:string/1,
        Default,
        Next
    ).

-spec int_with_default(
    binary(),
    binary(),
    integer(),
    fun((integer()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYT} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYT} |
    {error, list(gleam@dynamic:decode_error())}).
int_with_default(Long_name, Short_name, Default, Next) ->
    flag_with_default(
        Long_name,
        Short_name,
        fun gleam@dynamic:int/1,
        Default,
        Next
    ).

-spec float_with_default(
    binary(),
    binary(),
    float(),
    fun((float()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYZ} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYZ} |
    {error, list(gleam@dynamic:decode_error())}).
float_with_default(Long_name, Short_name, Default, Next) ->
    flag_with_default(
        Long_name,
        Short_name,
        fun gleam@dynamic:float/1,
        Default,
        Next
    ).

-spec bool(
    binary(),
    binary(),
    fun((boolean()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZC} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZC} |
    {error, list(gleam@dynamic:decode_error())}).
bool(Long_name, Short_name, Next) ->
    flag_with_default(
        Long_name,
        Short_name,
        fun gleam@dynamic:bool/1,
        false,
        Next
    ).

-spec bool_with_default(
    binary(),
    binary(),
    boolean(),
    fun((boolean()) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZF} |
        {error, list(gleam@dynamic:decode_error())}))
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FZF} |
    {error, list(gleam@dynamic:decode_error())}).
bool_with_default(Long_name, Short_name, Default, Next) ->
    flag_with_default(
        Long_name,
        Short_name,
        fun gleam@dynamic:bool/1,
        Default,
        Next
    ).

-spec fail(binary(), binary()) -> {ok, any()} |
    {error, list(gleam@dynamic:decode_error())}.
fail(Expected, Found) ->
    {error, [{decode_error, Expected, Found, []}]}.

-spec try_parse_float(binary()) -> {ok, gleam@dynamic:dynamic_()} | {error, nil}.
try_parse_float(Input) ->
    _pipe = gleam@float:parse(Input),
    gleam@result:map(_pipe, fun gleam_stdlib:identity/1).

-spec try_parse_int(binary()) -> {ok, gleam@dynamic:dynamic_()} | {error, nil}.
try_parse_int(Input) ->
    _pipe = gleam@int:parse(Input),
    gleam@result:map(_pipe, fun gleam_stdlib:identity/1).

-spec try_parse_bool(binary()) -> {ok, gleam@dynamic:dynamic_()} | {error, nil}.
try_parse_bool(Input) ->
    case Input of
        <<"true"/utf8>> ->
            {ok, gleam_stdlib:identity(true)};

        <<"True"/utf8>> ->
            {ok, gleam_stdlib:identity(true)};

        <<"false"/utf8>> ->
            {ok, gleam_stdlib:identity(false)};

        <<"False"/utf8>> ->
            {ok, gleam_stdlib:identity(false)};

        _ ->
            {error, nil}
    end.

-spec parse(binary()) -> gleam@dynamic:dynamic_().
parse(Input) ->
    _pipe = try_parse_float(Input),
    _pipe@1 = gleam@result:'or'(_pipe, try_parse_int(Input)),
    _pipe@2 = gleam@result:'or'(_pipe@1, try_parse_bool(Input)),
    gleam@result:unwrap(_pipe@2, gleam_stdlib:identity(Input)).

-spec prepare_arguments(list(binary())) -> {ok,
        list({binary(), gleam@dynamic:dynamic_()})} |
    {error, list(gleam@dynamic:decode_error())}.
prepare_arguments(Arguments) ->
    Arguments@1 = begin
        _pipe = Arguments,
        _pipe@1 = clad@internal@args:split_equals(_pipe),
        clad@internal@args:add_bools(_pipe@1)
    end,
    Chunked = gleam@list:sized_chunk(Arguments@1, 2),
    Chunked@1 = gleam@list:map(Chunked, fun(Chunk) -> case Chunk of
                [K, V] ->
                    {ok, {K, parse(V)}};

                _ ->
                    fail(<<"key/value pairs"/utf8>>, <<"dangling arg"/utf8>>)
            end end),
    gleam@result:all(Chunked@1).

-spec object(list({binary(), gleam@dynamic:dynamic_()})) -> gleam@dynamic:dynamic_().
object(Entries) ->
    gleam_stdlib:identity(maps:from_list(Entries)).

-spec decode(
    fun((gleam@dynamic:dynamic_()) -> {ok, FYB} |
        {error, list(gleam@dynamic:decode_error())}),
    list(binary())
) -> {ok, FYB} | {error, list(gleam@dynamic:decode_error())}.
decode(Decoder, Arguments) ->
    gleam@result:'try'(
        prepare_arguments(Arguments),
        fun(Arguments@1) -> _pipe = object(Arguments@1),
            Decoder(_pipe) end
    ).