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(LFT, LFU) :: {logger,
        binary(),
        integer(),
        fun(() -> binary()),
        gleam@option:option(LFU),
        list(logger_instance(LFT, LFU))}.

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

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

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

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

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

-spec append_instance(logger(LHE, LHF), logger_instance(LHE, LHF)) -> logger(LHE, LHF).
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(LID, LIE, gleam@dynamic:dynamic())) -> nil)
) -> {ok,
        gleam@erlang@process:subject(glimt@log_message:log_message(LID, LIE, 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(LHU, LHV, gleam@dynamic:dynamic())) -> nil)
) -> {ok, logger_instance(LHU, LHV)} | {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(LLC, LLD), glimt@log_message:log_level(), binary()) -> glimt@log_message:log_message(LLC, LLD, 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(LLJ, LLK),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()}
) -> glimt@log_message:log_message(LLJ, LLK, 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(LLU, LLV),
    glimt@log_message:log_message(LLU, LLV, 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(LIO, LIP), binary()) -> logger(LIO, LIP).
debug(Logger, Message) ->
    Log_message = mk_message(Logger, debug, Message),
    dispatch_log(Logger, Log_message),
    Logger.

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

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

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

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

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

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

-spec log_with_data(
    logger(LKM, LKN),
    glimt@log_message:log_level(),
    binary(),
    LKM
) -> logger(LKM, LKN).
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(LKS, LKT),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()},
    LKS
) -> logger(LKS, LKT).
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)).