mote

-module(mote@toml).
-compile([no_auto_import, nowarn_unused_vars]).

-export([parse/1, get/2, get_string/2]).
-export_type([toml_error/0, get_error/0, maybe_number/0, value/0, semantic_error/0, validate_location/0, return_term/0]).

-type toml_error() :: {tokenize, integer()} |
    {parse, integer()} |
    {semantic, semantic_error()} |
    {bad_return, validate_location(), return_term()}.

-type get_error() :: not_found | invalid_value.

-type maybe_number() :: {integer, integer()} |
    {floating, float()} |
    nan |
    infinity |
    negative_infinity.

-type value() :: {maybe_number, maybe_number()} |
    {binary, bitstring()} |
    {boolean, boolean()} |
    {value_list, list(value())} |
    {table, gleam@map:map_(bitstring(), value())}.

-type semantic_error() :: any().

-type validate_location() :: any().

-type return_term() :: any().

-spec iff(boolean(), GVQ, fun(() -> GVQ)) -> GVQ.
iff(Bool, Then, Else) ->
    case Bool of
        true ->
            Then;

        false ->
            Else()
    end.

-spec parse(binary()) -> {ok, gleam@map:map_(bitstring(), value())} |
    {error, toml_error()}.
parse(Field@0) ->
    tomerl:parse(Field@0).

-spec maybe_num(gleam@dynamic:dynamic()) -> {ok, maybe_number()} |
    {error, list(gleam@dynamic:decode_error())}.
maybe_num(Dyn) ->
    gleam@result:lazy_or(
        begin
            _pipe = gleam@dynamic:int(Dyn),
            gleam@result:map(_pipe, fun(Field@0) -> {integer, Field@0} end)
        end,
        fun() ->
            gleam@result:lazy_or(
                begin
                    _pipe@1 = gleam@dynamic:float(Dyn),
                    gleam@result:map(
                        _pipe@1,
                        fun(Field@0) -> {floating, Field@0} end
                    )
                end,
                fun() ->
                    gleam@result:lazy_or(
                        (iff(
                            mote@toml@erl:is_atom(Dyn, <<"nan"/utf8>>),
                            begin
                                _pipe@2 = nan,
                                {ok, _pipe@2}
                            end,
                            fun() ->
                                iff(
                                    mote@toml@erl:is_atom(
                                        Dyn,
                                        <<"infinity"/utf8>>
                                    ),
                                    begin
                                        _pipe@3 = infinity,
                                        {ok, _pipe@3}
                                    end,
                                    fun() ->
                                        iff(
                                            mote@toml@erl:is_atom(
                                                Dyn,
                                                <<"negative_infinity"/utf8>>
                                            ),
                                            begin
                                                _pipe@4 = negative_infinity,
                                                {ok, _pipe@4}
                                            end,
                                            fun() -> {error, []} end
                                        )
                                    end
                                )
                            end
                        )),
                        fun() ->
                            {error,
                                [{decode_error,
                                        <<"MaybeInt"/utf8>>,
                                        gleam@dynamic:classify(Dyn),
                                        []}]}
                        end
                    )
                end
            )
        end
    ).

-spec dyn_value(gleam@dynamic:dynamic()) -> {ok, value()} |
    {error, list(gleam@dynamic:decode_error())}.
dyn_value(Dyn) ->
    gleam@result:lazy_or(
        begin
            _pipe = maybe_num(Dyn),
            gleam@result:map(_pipe, fun(Field@0) -> {maybe_number, Field@0} end)
        end,
        fun() ->
            gleam@result:lazy_or(
                begin
                    _pipe@1 = gleam@dynamic:bit_string(Dyn),
                    gleam@result:map(
                        _pipe@1,
                        fun(Field@0) -> {binary, Field@0} end
                    )
                end,
                fun() ->
                    gleam@result:lazy_or(
                        begin
                            _pipe@2 = gleam@dynamic:bool(Dyn),
                            gleam@result:map(
                                _pipe@2,
                                fun(Field@0) -> {boolean, Field@0} end
                            )
                        end,
                        fun() ->
                            gleam@result:lazy_or(
                                begin
                                    _pipe@3 = Dyn,
                                    _pipe@4 = (gleam@dynamic:list(
                                        fun dyn_value/1
                                    ))(_pipe@3),
                                    gleam@result:map(
                                        _pipe@4,
                                        fun(Field@0) -> {value_list, Field@0} end
                                    )
                                end,
                                fun() ->
                                    gleam@result:lazy_or(
                                        begin
                                            _pipe@5 = Dyn,
                                            _pipe@6 = (gleam@dynamic:map(
                                                fun gleam@dynamic:bit_string/1,
                                                fun dyn_value/1
                                            ))(_pipe@5),
                                            gleam@result:map(
                                                _pipe@6,
                                                fun(Field@0) -> {table, Field@0} end
                                            )
                                        end,
                                        fun() ->
                                            {error,
                                                [{decode_error,
                                                        <<"Value"/utf8>>,
                                                        gleam@dynamic:classify(
                                                            Dyn
                                                        ),
                                                        []}]}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec get(gleam@map:map_(bitstring(), value()), list(binary())) -> {ok, value()} |
    {error, get_error()}.
get(Section, Path) ->
    gleam@result:'try'(
        tomerl:get(Section, Path),
        fun(Value) -> _pipe = dyn_value(Value),
            gleam@result:map_error(_pipe, fun(_) -> invalid_value end) end
    ).

-spec get_string(gleam@map:map_(bitstring(), value()), list(binary())) -> {ok,
        binary()} |
    {error, get_error()}.
get_string(Section, Path) ->
    gleam@result:'try'(get(Section, Path), fun(Value) -> case Value of
                {binary, Str} ->
                    case gleam@bit_string:to_string(Str) of
                        {ok, Str@1} ->
                            {ok, Str@1};

                        _ ->
                            {error, invalid_value}
                    end;

                _ ->
                    {error, invalid_value}
            end end).