glimt

-module(glimt).
-compile(no_auto_import).

-export([new/1, level/2, with_context/2, get_context/1, with_time_provider/2, new_stdout/1, 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]).
-export_type([logger/2, logger_instance/2]).

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

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

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

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

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

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

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

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

-spec append_instance(logger(HKE, HKF), logger_instance(HKE, HKF)) -> logger(HKE, HKF).
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_instance(
    binary(),
    glimt@log_message:log_level(),
    fun((glimt@log_message:log_message(HKU, HKV, any())) -> nil)
) -> {ok, logger_instance(HKU, HKV)} | {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 start_logger_actor(
    fun((glimt@log_message:log_message(any(), any(), any())) -> nil)
) -> {ok,
        gleam@erlang@process:subject(glimt@log_message:log_message(any(), any(), 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,
                    _@1,
                    _@2,
                    _@3,
                    _@4,
                    _@5,
                    _@6,
                    _@7,
                    _@8,
                    _@9,
                    _@10,
                    _@11} ->
                    Dispatch@1(
                        erlang:setelement(6, Message, {some, erlang:self()})
                    );

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

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

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

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

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

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

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

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

-spec log_with_data(
    logger(HNL, HNM),
    glimt@log_message:log_level(),
    binary(),
    HNL
) -> logger(HNL, HNM).
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(HNR, HNS),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()},
    HNR
) -> logger(HNR, HNS).
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 mk_message(logger(HOB, HOC), glimt@log_message:log_level(), binary()) -> glimt@log_message:log_message(HOB, HOC, 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(HOI, HOJ),
    glimt@log_message:log_level(),
    binary(),
    {ok, any()} | {error, any()}
) -> glimt@log_message:log_message(HOI, HOJ, 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(HOT, HOU),
    glimt@log_message:log_message(HOT, HOU, gleam@dynamic:dynamic())
) -> nil.
dispatch_log(Logger, Log_message) ->
    {log_message,
        _@1,
        _@2,
        _@3,
        _@4,
        _@5,
        _@6,
        Level_value,
        _@7,
        _@8,
        _@9,
        _@10} = 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
                                )
                            );

                        _@11 ->
                            nil
                    end;

                _@12 ->
                    nil
            end
        end
    ).

-spec now_iso() -> binary().
now_iso() ->
    _pipe = birl@datetime:now(),
    birl@datetime:to_iso(_pipe).