glog

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

-export([new/0, has_field/2, get_field/2, add/3, add_field/2, add_option/3, add_error/2, add_result/3, add_fields/2, new_with/1, emergency/2, alert/2, critical/2, error/2, warning/2, info/2, notice/2, debug/2, set_primary_log_level/1, set_handler_log_level/2, set_default_config/0, emergencyf/3, alertf/3, criticalf/3, errorf/3, warningf/3, infof/3, noticef/3, debugf/3]).
-export_type([glog/0]).

-opaque glog() :: {glog,
        gleam@dict:dict(gleam@erlang@atom:atom_(), gleam@dynamic:dynamic_())}.

-spec new() -> glog().
new() ->
    {glog, gleam@dict:new()}.

-spec has_field(glog(), binary()) -> boolean().
has_field(Logger, Key) ->
    gleam@dict:has_key(erlang:element(2, Logger), erlang:binary_to_atom(Key)).

-spec get_field(glog(), binary()) -> {ok, glog@field:field()} | {error, nil}.
get_field(Logger, Key) ->
    _pipe = erlang:element(2, Logger),
    _pipe@1 = gleam@dict:get(_pipe, erlang:binary_to_atom(Key)),
    gleam@result:map(_pipe@1, fun(Value) -> glog@field:new(Key, Value) end).

-spec add(glog(), binary(), any()) -> glog().
add(Logger, Key, Value) ->
    {glog,
        begin
            _pipe = erlang:element(2, Logger),
            gleam@dict:insert(
                _pipe,
                erlang:binary_to_atom(Key),
                gleam@dynamic:from(Value)
            )
        end}.

-spec add_field(glog(), glog@field:field()) -> glog().
add_field(Logger, F) ->
    {glog,
        begin
            _pipe = erlang:element(2, Logger),
            gleam@dict:insert(
                _pipe,
                erlang:binary_to_atom(glog@field:key(F)),
                glog@field:value(F)
            )
        end}.

-spec add_option(glog(), binary(), gleam@option:option(any())) -> glog().
add_option(Logger, Key, O) ->
    case O of
        {some, V} ->
            _pipe = Logger,
            add(_pipe, Key, V);

        none ->
            Logger
    end.

-spec add_error(glog(), any()) -> glog().
add_error(Logger, Error) ->
    _pipe = Logger,
    add(_pipe, <<"error"/utf8>>, Error).

-spec add_result(glog(), binary(), {ok, any()} | {error, any()}) -> glog().
add_result(Logger, Key, R) ->
    case R of
        {ok, V} ->
            _pipe = Logger,
            add(_pipe, Key, V);

        {error, E} ->
            _pipe@1 = Logger,
            add_error(_pipe@1, E)
    end.

-spec args_to_dynamic(list(glog@arg:arg())) -> list(gleam@dynamic:dynamic_()).
args_to_dynamic(Args) ->
    _pipe = Args,
    gleam@list:map(_pipe, fun(A) -> gleam@dynamic:from(glog@arg:value(A)) end).

-spec fields_to_dynamic(list(glog@field:field())) -> gleam@dict:dict(gleam@erlang@atom:atom_(), gleam@dynamic:dynamic_()).
fields_to_dynamic(Fields) ->
    maps:from_list(
        begin
            _pipe = Fields,
            gleam@list:map(
                _pipe,
                fun(F) ->
                    {erlang:binary_to_atom(glog@field:key(F)),
                        glog@field:value(F)}
                end
            )
        end
    ).

-spec add_fields(glog(), list(glog@field:field())) -> glog().
add_fields(Logger, F) ->
    {glog, gleam@dict:merge(erlang:element(2, Logger), fields_to_dynamic(F))}.

-spec new_with(gleam@option:option(list(glog@field:field()))) -> glog().
new_with(With) ->
    case With of
        {some, Fields} ->
            _pipe = new(),
            add_fields(_pipe, Fields);

        none ->
            new()
    end.

-spec log(glog(), glog@level:level(), binary()) -> glog().
log(Logger, Lvl, Message) ->
    New_logger = begin
        _pipe = Logger,
        add(_pipe, <<"msg"/utf8>>, Message)
    end,
    logger:log(Lvl, erlang:element(2, New_logger)),
    Logger.

-spec emergency(glog(), binary()) -> glog().
emergency(Logger, Message) ->
    log(Logger, emergency, Message).

-spec alert(glog(), binary()) -> glog().
alert(Logger, Message) ->
    log(Logger, alert, Message).

-spec critical(glog(), binary()) -> glog().
critical(Logger, Message) ->
    log(Logger, critical, Message).

-spec error(glog(), binary()) -> glog().
error(Logger, Message) ->
    log(Logger, error, Message).

-spec warning(glog(), binary()) -> glog().
warning(Logger, Message) ->
    log(Logger, warning, Message).

-spec info(glog(), binary()) -> glog().
info(Logger, Message) ->
    log(Logger, info, Message).

-spec notice(glog(), binary()) -> glog().
notice(Logger, Message) ->
    log(Logger, notice, Message).

-spec debug(glog(), binary()) -> glog().
debug(Logger, Message) ->
    log(Logger, debug, Message).

-spec set_primary_log_level(glog@level:config_level()) -> nil.
set_primary_log_level(Lvl) ->
    logger:set_primary_config(
        erlang:binary_to_atom(<<"lvl"/utf8>>),
        gleam@dynamic:from(Lvl)
    ).

-spec set_handler_log_level(binary(), glog@level:config_level()) -> nil.
set_handler_log_level(Handler, Lvl) ->
    logger:set_handler_config(
        erlang:binary_to_atom(Handler),
        erlang:binary_to_atom(<<"lvl"/utf8>>),
        gleam@dynamic:from(Lvl)
    ).

-spec set_default_config() -> nil.
set_default_config() ->
    logger:set_handler_config(
        erlang:binary_to_atom(<<"default"/utf8>>),
        erlang:binary_to_atom(<<"formatter"/utf8>>),
        gleam@dynamic:from(
            {gleam@dynamic:from(
                    erlang:binary_to_atom(<<"logger_formatter"/utf8>>)
                ),
                gleam@dynamic:from(
                    maps:from_list(
                        [{erlang:binary_to_atom(<<"single_line"/utf8>>),
                                erlang:binary_to_atom(<<"true"/utf8>>)},
                            {erlang:binary_to_atom(<<"legacy_header"/utf8>>),
                                erlang:binary_to_atom(<<"false"/utf8>>)}]
                    )
                )}
        )
    ).

-spec logf(glog(), glog@level:level(), binary(), list(glog@arg:arg())) -> glog().
logf(Logger, Lvl, String, Values) ->
    log(Logger, Lvl, io_lib:format(String, args_to_dynamic(Values))).

-spec emergencyf(glog(), binary(), list(glog@arg:arg())) -> glog().
emergencyf(Logger, String, Values) ->
    logf(Logger, emergency, String, Values).

-spec alertf(glog(), binary(), list(glog@arg:arg())) -> glog().
alertf(Logger, String, Values) ->
    logf(Logger, alert, String, Values).

-spec criticalf(glog(), binary(), list(glog@arg:arg())) -> glog().
criticalf(Logger, String, Values) ->
    logf(Logger, critical, String, Values).

-spec errorf(glog(), binary(), list(glog@arg:arg())) -> glog().
errorf(Logger, String, Values) ->
    logf(Logger, error, String, Values).

-spec warningf(glog(), binary(), list(glog@arg:arg())) -> glog().
warningf(Logger, String, Values) ->
    logf(Logger, warning, String, Values).

-spec infof(glog(), binary(), list(glog@arg:arg())) -> glog().
infof(Logger, String, Values) ->
    logf(Logger, info, String, Values).

-spec noticef(glog(), binary(), list(glog@arg:arg())) -> glog().
noticef(Logger, String, Values) ->
    logf(Logger, notice, String, Values).

-spec debugf(glog(), binary(), list(glog@arg:arg())) -> glog().
debugf(Logger, String, Values) ->
    logf(Logger, debug, String, Values).