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

-export([with_default/2, string/2, int/2, float/2, bool/2, decode/2]).

-spec with_default(
    fun((gleam@dynamic:dynamic_()) -> {ok, FYO} |
        {error, list(gleam@dynamic:decode_error())}),
    FYO
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYO} |
    {error, list(gleam@dynamic:decode_error())}).
with_default(Decoder, Default) ->
    fun(Data) ->
        gleam@result:try_recover(Decoder(Data), fun(_) -> {ok, Default} end)
    end.

-spec do_long_name(
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FYU} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYU} |
    {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, FYX} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYX} |
    {error, list(gleam@dynamic:decode_error())}).
do_short_name(Short_name, Decoder) ->
    gleam@dynamic:field(<<"-"/utf8, Short_name/binary>>, Decoder).

-spec arg(
    binary(),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FYR} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FYR} |
    {error, list(gleam@dynamic:decode_error())}).
arg(Long_name, Short_name, Decoder) ->
    gleam@dynamic:any(
        [do_long_name(Long_name, Decoder), do_short_name(Short_name, Decoder)]
    ).

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

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

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

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

-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
    ).