dot_env

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

-export([load_with_opts/1, load/0]).
-export_type([opts/0, dot_env/0]).

-type opts() :: {opts, binary(), boolean(), boolean()} | default.

-opaque dot_env() :: {dot_env, binary(), boolean(), boolean()}.

-spec recursively_set_environment_variables(
    dot_env(),
    list({binary(), binary()})
) -> nil.
recursively_set_environment_variables(Config, Kv_pairs) ->
    case Kv_pairs of
        [] ->
            nil;

        [Pair] ->
            dot_env_ffi:set_env(case erlang:element(4, Config) of
                    true ->
                        gleam@string:uppercase(erlang:element(1, Pair));

                    false ->
                        erlang:element(1, Pair)
                end, erlang:element(2, Pair));

        [Pair@1 | Rest] ->
            dot_env_ffi:set_env(case erlang:element(4, Config) of
                    true ->
                        gleam@string:uppercase(erlang:element(1, Pair@1));

                    false ->
                        erlang:element(1, Pair@1)
                end, erlang:element(2, Pair@1)),
            recursively_set_environment_variables(Config, Rest)
    end.

-spec read_file(dot_env()) -> {ok, binary()} | {error, binary()}.
read_file(Dotenv) ->
    case simplifile:is_file(erlang:element(2, Dotenv)) of
        true ->
            case simplifile:read(erlang:element(2, Dotenv)) of
                {ok, Contents} ->
                    {ok, Contents};

                {error, _} ->
                    Msg = <<<<"Unable to read file at `"/utf8,
                            (erlang:element(2, Dotenv))/binary>>/binary,
                        "`, ensure the file exists and is readable"/utf8>>,
                    gleam@io:println(Msg),
                    {error, Msg}
            end;

        false ->
            {error,
                <<<<"Specified file `"/utf8,
                        (erlang:element(2, Dotenv))/binary>>/binary,
                    "` does not exist"/utf8>>}
    end.

-spec load_and_return_error(dot_env()) -> {ok, nil} | {error, binary()}.
load_and_return_error(Dotenv) ->
    gleam@result:'try'(
        read_file(Dotenv),
        fun(Content) ->
            gleam@result:'try'(
                dot_env@internal@parser:parse(Content),
                fun(Kv_pairs) ->
                    _pipe = Dotenv,
                    recursively_set_environment_variables(_pipe, Kv_pairs),
                    {ok, nil}
                end
            )
        end
    ).

-spec load_with_opts(opts()) -> nil.
load_with_opts(Opts) ->
    Dotenv = case Opts of
        {opts, Path, Debug, Capitalize} ->
            {dot_env, Path, Debug, Capitalize};

        default ->
            {dot_env, <<".env"/utf8>>, true, true}
    end,
    _pipe = Dotenv,
    _pipe@1 = load_and_return_error(_pipe),
    (fun(R) -> case R of
            {ok, _} ->
                nil;

            {error, Msg} ->
                case erlang:element(3, Dotenv) of
                    true ->
                        gleam@io:println_error(Msg);

                    false ->
                        nil
                end
        end end)(_pipe@1).

-spec load() -> nil.
load() ->
    load_with_opts(default).