glimt

-module(glimt).
-compile([no_auto_import, nowarn_unused_vars]).

-export([level/2, with_context/2, get_context/1, with_time_provider/2, append_instance/2, stdout_instance/2, stdout_anonymous_instance/1, start_instance/3, debug/2, info/2, warning/2, trace/2, error/3, fatal/3, log/3, log_with_data/4, log_error_with_data/5, new/1, new_stdout/1]).
-export_type([logger/2, logger_instance/2]).

-opaque logger(MWW, MWX) :: {logger,
        binary(),
        integer(),
        fun(() -> binary()),
        gleam@option:option(MWX),
        list(logger_instance(MWW, MWX))}.

-type logger_instance(MWY, MWZ) :: {direct,
        gleam@option:option(binary()),
        integer(),
        fun((glimt@log_message:log_message(MWY, MWZ, gleam@dynamic:dynamic_())) -> nil)} |
    {actor,
        gleam@option:option(binary()),
        integer(),
        gleam@erlang@process:subject(glimt@log_message:log_message(MWY, MWZ, gleam@dynamic:dynamic_()))}.

-spec level(logger(MXK, MXL), glimt@log_message:log_level()) -> logger(MXK, MXL).
level(Logger, Level) ->
    erlang:setelement(3, Logger, glimt@log_message:level_value(Level)).

-spec with_context(logger(MXQ, MXR), MXR) -> logger(MXQ, MXR).
with_context(Logger, Context) ->
    erlang:setelement(5, Logger, {some, Context}).

-spec get_context(logger(any(), MXW)) -> gleam@option:option(MXW).
get_context(Logger) ->
    erlang:element(5, Logger).

-spec with_time_provider(logger(MYA, MYB), fun(() -> binary())) -> logger(MYA, MYB).
with_time_provider(Logger, Time_provider) ->
    erlang:setelement(4, Logger, Time_provider).

-spec append_instance(logger(MYH, MYI), logger_instance(MYH, MYI)) -> logger(MYH, MYI).
append_instance(Logger, Instance) ->
    erlang:setelement(6, Logger, [Instance | erlang:element(6, Logger)]).

-spec stdout_instance(binary(), glimt@log_message:log_level()) -> logger_instance(any(), any()).
stdout_instance(Name, Level) ->
    {direct,
        {some, Name},
        glimt@log_message:level_value(Level),
        glimt@dispatcher@stdout:dispatcher(
            fun glimt@serializer@basic:basic_serializer/1
        )}.

-spec stdout_anonymous_instance(glimt@log_message:log_level()) -> logger_instance(any(), any()).
stdout_anonymous_instance(Level) ->
    {direct,
        none,
        glimt@log_message:level_value(Level),
        glimt@dispatcher@stdout:dispatcher(
            fun glimt@serializer@basic:basic_serializer/1
        )}.

-spec start_logger_actor(
    fun((glimt@log_message:log_message(MZG, MZH, gleam@dynamic:dynamic_())) -> nil)
) -> {ok,
        gleam@erlang@process:subject(glimt@log_message:log_message(MZG, MZH, gleam@dynamic:dynamic_()))} |
    {error, gleam@otp@actor:start_error()}.
start_logger_actor(Dispatch) ->
    gleam@otp@actor:start(
        Dispatch,
        fun(Message, Dispatch@1) ->
            case Message of
                {log_message, _, _, _, _, _, _, _, _, _, _, _} ->
                    Dispatch@1(
                        erlang:setelement(6, Message, {some, erlang:self()})
                    );

                _ ->
                    nil
            end,
            {continue, Dispatch@1}
        end
    ).

-spec start_instance(
    binary(),
    glimt@log_message:log_level(),
    fun((glimt@log_message:log_message(MYX, MYY, gleam@dynamic:dynamic_())) -> nil)
) -> {ok, logger_instance(MYX, MYY)} | {error, gleam@otp@actor:start_error()}.
start_instance(Name, Level, Dispatch) ->
    _pipe = start_logger_actor(Dispatch),
    gleam@result:map(
        _pipe,
        fun(Subject) ->
            {actor, {some, Name}, glimt@log_message:level_value(Level), Subject}
        end
    ).

-spec mk_message(logger(NCF, NCG), glimt@log_message:log_level(), binary()) -> glimt@log_message:log_message(NCF, NCG, gleam@dynamic:dynamic_()).
mk_message(Logger, Level, Message) ->
    {log_message,
        (erlang:element(4, Logger))(),
        erlang:element(2, Logger),
        erlang:self(),
        none,
        none,
        Level,
        glimt@log_message:level_value(Level),
        Message,
        none,
        none,
        erlang:element(5, Logger)}.

-spec mk_error_message(
    logger(NCM, NCN),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()}
) -> glimt@log_message:log_message(NCM, NCN, gleam@dynamic:dynamic_()).
mk_error_message(Logger, Level, Message, Error) ->
    Dynamic_result = case Error of
        {ok, A} ->
            {some, {ok, gleam@dynamic:from(A)}};

        {error, A@1} ->
            {some, {error, gleam@dynamic:from(A@1)}}
    end,
    {log_message,
        (erlang:element(4, Logger))(),
        erlang:element(2, Logger),
        erlang:self(),
        none,
        none,
        Level,
        glimt@log_message:level_value(Level),
        Message,
        Dynamic_result,
        none,
        erlang:element(5, Logger)}.

-spec dispatch_log(
    logger(NCX, NCY),
    glimt@log_message:log_message(NCX, NCY, gleam@dynamic:dynamic_())
) -> nil.
dispatch_log(Logger, Log_message) ->
    {log_message, _, _, _, _, _, _, Level_value, _, _, _, _} = Log_message,
    _pipe = erlang:element(6, Logger),
    gleam@list:each(
        _pipe,
        fun(Impl) ->
            case erlang:element(8, Log_message) >= erlang:element(3, Logger) of
                true ->
                    case Impl of
                        {direct, Instance_name, Level_min_value, Dispatch} when Level_value >= Level_min_value ->
                            Dispatch(
                                erlang:setelement(5, Log_message, Instance_name)
                            );

                        {actor, Instance_name@1, Level_min_value@1, Subject} when Level_value >= Level_min_value@1 ->
                            _pipe@1 = Subject,
                            gleam@erlang@process:send(
                                _pipe@1,
                                erlang:setelement(
                                    5,
                                    Log_message,
                                    Instance_name@1
                                )
                            );

                        _ ->
                            nil
                    end;

                _ ->
                    nil
            end
        end
    ).

-spec debug(logger(MZR, MZS), binary()) -> logger(MZR, MZS).
debug(Logger, Message) ->
    Log_message = mk_message(Logger, debug, Message),
    dispatch_log(Logger, Log_message),
    Logger.

-spec info(logger(MZX, MZY), binary()) -> logger(MZX, MZY).
info(Logger, Message) ->
    Log_message = mk_message(Logger, info, Message),
    dispatch_log(Logger, Log_message),
    Logger.

-spec warning(logger(NAD, NAE), binary()) -> logger(NAD, NAE).
warning(Logger, Message) ->
    Log_message = mk_message(Logger, warning, Message),
    dispatch_log(Logger, Log_message),
    Logger.

-spec trace(logger(NAJ, NAK), binary()) -> logger(NAJ, NAK).
trace(Logger, Message) ->
    Log_message = mk_message(Logger, trace, Message),
    dispatch_log(Logger, Log_message),
    Logger.

-spec error(logger(NAP, NAQ), binary(), {ok, any()} | {error, any()}) -> logger(NAP, NAQ).
error(Logger, Message, Error) ->
    Log_message = mk_error_message(Logger, error, Message, Error),
    dispatch_log(Logger, Log_message),
    Logger.

-spec fatal(logger(NAZ, NBA), binary(), {ok, any()} | {error, any()}) -> logger(NAZ, NBA).
fatal(Logger, Message, Error) ->
    Log_message = mk_error_message(Logger, fatal, Message, Error),
    dispatch_log(Logger, Log_message),
    Logger.

-spec log(logger(NBJ, NBK), glimt@log_message:log_level(), binary()) -> logger(NBJ, NBK).
log(Logger, Level, Message) ->
    Log_message = mk_message(Logger, Level, Message),
    dispatch_log(Logger, Log_message),
    Logger.

-spec log_with_data(
    logger(NBP, NBQ),
    glimt@log_message:log_level(),
    binary(),
    NBP
) -> logger(NBP, NBQ).
log_with_data(Logger, Level, Message, Data) ->
    dispatch_log(
        Logger,
        {log_message,
            (erlang:element(4, Logger))(),
            erlang:element(2, Logger),
            erlang:self(),
            none,
            none,
            Level,
            glimt@log_message:level_value(Level),
            Message,
            none,
            {some, Data},
            erlang:element(5, Logger)}
    ),
    Logger.

-spec log_error_with_data(
    logger(NBV, NBW),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()},
    NBV
) -> logger(NBV, NBW).
log_error_with_data(Logger, Level, Message, Error, Data) ->
    Dynamic_result = case Error of
        {ok, A} ->
            {some, {ok, gleam@dynamic:from(A)}};

        {error, A@1} ->
            {some, {error, gleam@dynamic:from(A@1)}}
    end,
    dispatch_log(
        Logger,
        {log_message,
            (erlang:element(4, Logger))(),
            erlang:element(2, Logger),
            erlang:self(),
            none,
            none,
            Level,
            glimt@log_message:level_value(Level),
            Message,
            Dynamic_result,
            {some, Data},
            erlang:element(5, Logger)}
    ),
    Logger.

-spec now_iso() -> binary().
now_iso() ->
    _pipe = birl@time:now(),
    birl@time:to_iso8601(_pipe).

-spec new(binary()) -> logger(any(), any()).
new(Name) ->
    {logger, Name, glimt@log_message:level_value(all), fun now_iso/0, none, []}.

-spec new_stdout(binary()) -> logger(nil, {binary(), binary()}).
new_stdout(Name) ->
    _pipe = new(Name),
    append_instance(_pipe, stdout_anonymous_instance(all)).