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

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

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

-type env_error() :: {missing_key_error, binary()} |
    {invalid_env_value, binary(), type()} |
    {validation_error, list(gleam@dynamic:decode_error())}.

-spec do_parse({binary(), type()}, binary()) -> {ok,
        {binary(), gleam@dynamic:dynamic_()}} |
    {error, env_error()}.
do_parse(Definition, Value) ->
    case Definition of
        {Key, bool} ->
            case glenv@internal@parse:bool(Key, Value) of
                {ok, Resolution} ->
                    {ok, Resolution};

                {error, _} ->
                    {error, {invalid_env_value, Key, bool}}
            end;

        {Key@1, float} ->
            case glenv@internal@parse:float(Key@1, Value) of
                {ok, Resolution@1} ->
                    {ok, Resolution@1};

                {error, _} ->
                    {error, {invalid_env_value, Key@1, float}}
            end;

        {Key@2, int} ->
            case glenv@internal@parse:int(Key@2, Value) of
                {ok, Resolution@2} ->
                    {ok, Resolution@2};

                {error, _} ->
                    {error, {invalid_env_value, Key@2, int}}
            end;

        {Key@3, string} ->
            case glenv@internal@parse:string(Key@3, Value) of
                {ok, Resolution@3} ->
                    {ok, Resolution@3};

                {error, _} ->
                    {error, {invalid_env_value, Key@3, string}}
            end
    end.

-spec parse(list({binary(), type()})) -> {ok,
        list({binary(), gleam@dynamic:dynamic_()})} |
    {error, env_error()}.
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,
                        {missing_key_error,
                            erlang:element(1, Normalized_definition)}}
            end
        end
    ).

-spec load(decode:decoder(GDJ), list({binary(), type()})) -> {ok, GDJ} |
    {error, env_error()}.
load(Decoder, Definitions) ->
    gleam@result:'try'(
        parse(Definitions),
        fun(Parsed_env) ->
            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} ->
                    {error, {validation_error, Err}}
            end
        end
    ).