glenv

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

-export([parse/1, load/2]).
-export_type([type/0]).

-type type() :: bool | float | int | string.

-spec parse_bool({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, nil}.
parse_bool(Definition, Value) ->
    Resolution = begin
        _pipe = [<<"true"/utf8>>, <<"yes"/utf8>>, <<"1"/utf8>>],
        gleam@list:contains(_pipe, gleam@string:lowercase(Value))
    end,
    {ok, {erlang:element(1, Definition), gleam@dynamic:from(Resolution)}}.

-spec parse_float({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, nil}.
parse_float(Definition, Value) ->
    case gleam@float:parse(Value) of
        {ok, Resolution} ->
            {ok,
                {erlang:element(1, Definition), gleam@dynamic:from(Resolution)}};

        {error, _} ->
            {error, nil}
    end.

-spec parse_int({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, nil}.
parse_int(Definition, Value) ->
    case gleam@int:parse(Value) of
        {ok, Resolution} ->
            {ok,
                {erlang:element(1, Definition), gleam@dynamic:from(Resolution)}};

        {error, _} ->
            {error, nil}
    end.

-spec parse_string({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, nil}.
parse_string(Definition, Value) ->
    {ok, {erlang:element(1, Definition), gleam@dynamic:from(Value)}}.

-spec do_parse({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, nil}.
do_parse(Definition, Value) ->
    case Definition of
        {_, bool} ->
            parse_bool(Definition, Value);

        {_, float} ->
            parse_float(Definition, Value);

        {_, int} ->
            parse_int(Definition, Value);

        {_, string} ->
            parse_string(Definition, Value)
    end.

-spec parse(list({binary(), type()})) -> {ok,
        list({binary(), gleam@dynamic:dynamic_()})} |
    {error, nil}.
parse(Definitions) ->
    Env = envoy_ffi:all(),
    gleam@list:try_map(
        Definitions,
        fun(Definition) ->
            Normalized_definition = {gleam@string:uppercase(
                    erlang:element(1, Definition)
                ),
                erlang:element(2, Definition)},
            case gleam@dict:get(Env, erlang:element(1, Normalized_definition)) of
                {ok, Value} ->
                    do_parse(Normalized_definition, Value);

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

-spec load(decode:decoder(GBY), list({binary(), type()})) -> {ok, GBY} |
    {error, nil}.
load(Decoder, Definitions) ->
    _assert_subject = parse(Definitions),
    {ok, Parsed_env} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"glenv"/utf8>>,
                        function => <<"load"/utf8>>,
                        line => 74})
    end,
    case begin
        _pipe = Parsed_env,
        _pipe@1 = maps:from_list(_pipe),
        _pipe@2 = gleam@dynamic:from(_pipe@1),
        decode:from(Decoder, _pipe@2)
    end of
        {ok, Env} ->
            {ok, Env};

        {error, Err} ->
            gleam@io:debug(Err),
            {error, nil}
    end.