glight

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

-export([set_level/2, set_is_color/2, with/3, emergency/2, alert/2, critical/2, error/2, warn/2, notice/2, info/2, debug/2, start/1, must_start/1]).
-export_type([state/0, message/0, log_config/0, log_context/0, transport/0, glight_error/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type state() :: {state,
        list(fun((logging:log_level(), binary(), gleam@dict:dict(binary(), binary()), log_config()) -> nil))}.

-type message() :: {log,
        gleam@erlang@process:subject(boolean()),
        logging:log_level(),
        binary(),
        gleam@dict:dict(binary(), binary()),
        log_config()}.

-type log_config() :: {log_config, logging:log_level(), boolean()}.

-type log_context() :: {log_context,
        gleam@erlang@process:subject(message()),
        log_config(),
        gleam@dict:dict(binary(), binary())}.

-type transport() :: console_transport |
    {file_transport, binary()} |
    {custom_transport,
        fun((logging:log_level(), binary(), gleam@dict:dict(binary(), binary()), log_config()) -> nil)}.

-type glight_error() :: {file_stream_error,
        file_streams@file_stream_error:file_stream_error()} |
    {actor_start_error, gleam@otp@actor:start_error()}.

-file("src/glight.gleam", 40).
-spec set_level(log_context(), logging:log_level()) -> log_context().
set_level(Ctx, Level) ->
    _record = Ctx,
    {log_context,
        erlang:element(2, _record),
        begin
            _record@1 = erlang:element(3, Ctx),
            {log_config, Level, erlang:element(3, _record@1)}
        end,
        erlang:element(4, _record)}.

-file("src/glight.gleam", 44).
-spec set_is_color(log_context(), boolean()) -> log_context().
set_is_color(Ctx, Is_color) ->
    _record = Ctx,
    {log_context,
        erlang:element(2, _record),
        begin
            _record@1 = erlang:element(3, Ctx),
            {log_config, erlang:element(2, _record@1), Is_color}
        end,
        erlang:element(4, _record)}.

-file("src/glight.gleam", 81).
-spec with(log_context(), binary(), binary()) -> log_context().
with(Ctx, Key, Value) ->
    _record = Ctx,
    {log_context,
        erlang:element(2, _record),
        erlang:element(3, _record),
        gleam@dict:insert(erlang:element(4, Ctx), Key, Value)}.

-file("src/glight.gleam", 117).
-spec handle_message(message(), state()) -> gleam@otp@actor:next(message(), state()).
handle_message(Message, State) ->
    case Message of
        {log, Caller, Level, Log_msg, Data, Config} ->
            gleam@list:map(
                erlang:element(2, State),
                fun(Log) -> Log(Level, Log_msg, Data, Config) end
            ),
            gleam@otp@actor:send(Caller, true),
            gleam@otp@actor:continue(State)
    end.

-file("src/glight.gleam", 254).
-spec level_to_string(logging:log_level()) -> binary().
level_to_string(Level) ->
    case Level of
        emergency ->
            <<"emergency"/utf8>>;

        alert ->
            <<"alert"/utf8>>;

        critical ->
            <<"critical"/utf8>>;

        error ->
            <<"error"/utf8>>;

        warning ->
            <<"warn"/utf8>>;

        notice ->
            <<"notice"/utf8>>;

        info ->
            <<"info"/utf8>>;

        debug ->
            <<"debug"/utf8>>
    end.

-file("src/glight.gleam", 185).
-spec file_out(binary()) -> {ok,
        fun((logging:log_level(), binary(), gleam@dict:dict(binary(), binary()), any()) -> nil)} |
    {error, glight_error()}.
file_out(File) ->
    _pipe = file_streams@file_stream:open(File, [append]),
    _pipe@1 = gleam@result:map_error(
        _pipe,
        fun(Field@0) -> {file_stream_error, Field@0} end
    ),
    gleam@result:map(
        _pipe@1,
        fun(Stream) ->
            fun(Log_level, Log_msg, Data, _) ->
                Log = <<(begin
                        _pipe@9 = [{<<"time"/utf8>>,
                                begin
                                    _pipe@2 = birl:now(),
                                    _pipe@3 = birl:to_iso8601(_pipe@2),
                                    gleam@json:string(_pipe@3)
                                end},
                            {<<"level"/utf8>>,
                                begin
                                    _pipe@4 = Log_level,
                                    _pipe@5 = level_to_string(_pipe@4),
                                    gleam@json:string(_pipe@5)
                                end},
                            {<<"msg"/utf8>>,
                                begin
                                    _pipe@6 = Log_msg,
                                    gleam@json:string(_pipe@6)
                                end} |
                            begin
                                _pipe@7 = Data,
                                _pipe@8 = maps:to_list(_pipe@7),
                                gleam@list:map(
                                    _pipe@8,
                                    fun(E) ->
                                        {erlang:element(1, E),
                                            gleam@json:string(
                                                erlang:element(2, E)
                                            )}
                                    end
                                )
                            end],
                        _pipe@10 = gleam@json:object(_pipe@9),
                        gleam@json:to_string(_pipe@10)
                    end)/binary,
                    "\n"/utf8>>,
                case file_streams@file_stream:write_bytes(
                    Stream,
                    <<Log/binary>>
                ) of
                    {error, Err} ->
                        logging:log(
                            error,
                            <<"file_stream_write_error: "/utf8,
                                (gleam@string:inspect(Err))/binary>>
                        ),
                        nil;

                    _ ->
                        nil
                end,
                case file_streams@file_stream:sync(Stream) of
                    {error, Err@1} ->
                        logging:log(
                            error,
                            <<"file_stream_sync_error: "/utf8,
                                (gleam@string:inspect(Err@1))/binary>>
                        ),
                        nil;

                    _ ->
                        nil
                end,
                nil
            end
        end
    ).

-file("src/glight.gleam", 294).
-spec level_to_cmp(logging:log_level()) -> integer().
level_to_cmp(Level) ->
    case Level of
        emergency ->
            0;

        alert ->
            1;

        critical ->
            2;

        error ->
            3;

        warning ->
            4;

        notice ->
            5;

        info ->
            6;

        debug ->
            7
    end.

-file("src/glight.gleam", 307).
-spec should_log(logging:log_level(), logging:log_level()) -> boolean().
should_log(Log_level, Configured_level) ->
    level_to_cmp(Log_level) =< level_to_cmp(Configured_level).

-file("src/glight.gleam", 85).
-spec log(log_context(), logging:log_level(), binary()) -> boolean().
log(Ctx, Level, Log_msg) ->
    case should_log(Level, erlang:element(2, erlang:element(3, Ctx))) of
        true ->
            gleam@otp@actor:call(
                erlang:element(2, Ctx),
                fun(Client) ->
                    {log,
                        Client,
                        Level,
                        Log_msg,
                        erlang:element(4, Ctx),
                        erlang:element(3, Ctx)}
                end,
                100
            );

        false ->
            false
    end.

-file("src/glight.gleam", 49).
-spec emergency(log_context(), binary()) -> boolean().
emergency(Ctx, Log_msg) ->
    log(Ctx, emergency, Log_msg).

-file("src/glight.gleam", 53).
-spec alert(log_context(), binary()) -> boolean().
alert(Ctx, Log_msg) ->
    log(Ctx, alert, Log_msg).

-file("src/glight.gleam", 57).
-spec critical(log_context(), binary()) -> boolean().
critical(Ctx, Log_msg) ->
    log(Ctx, critical, Log_msg).

-file("src/glight.gleam", 61).
-spec error(log_context(), binary()) -> boolean().
error(Ctx, Log_msg) ->
    log(Ctx, error, Log_msg).

-file("src/glight.gleam", 65).
-spec warn(log_context(), binary()) -> boolean().
warn(Ctx, Log_msg) ->
    log(Ctx, warning, Log_msg).

-file("src/glight.gleam", 69).
-spec notice(log_context(), binary()) -> boolean().
notice(Ctx, Log_msg) ->
    log(Ctx, notice, Log_msg).

-file("src/glight.gleam", 73).
-spec info(log_context(), binary()) -> boolean().
info(Ctx, Log_msg) ->
    log(Ctx, info, Log_msg).

-file("src/glight.gleam", 77).
-spec debug(log_context(), binary()) -> boolean().
debug(Ctx, Log_msg) ->
    log(Ctx, debug, Log_msg).

-file("src/glight.gleam", 230).
-spec red(binary()) -> binary().
red(S) ->
    <<<<"\x{001b}[91m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 234).
-spec magenta(binary()) -> binary().
magenta(S) ->
    <<<<"\x{001b}[95m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 238).
-spec yellow(binary()) -> binary().
yellow(S) ->
    <<<<"\x{001b}[93m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 242).
-spec green(binary()) -> binary().
green(S) ->
    <<<<"\x{001b}[92m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 246).
-spec blue(binary()) -> binary().
blue(S) ->
    <<<<"\x{001b}[94m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 250).
-spec grey(binary()) -> binary().
grey(S) ->
    <<<<"\x{001b}[90m"/utf8, S/binary>>/binary, "\x{001b}[0m"/utf8>>.

-file("src/glight.gleam", 267).
-spec level_to_std_out_string(logging:log_level(), log_config()) -> binary().
level_to_std_out_string(Level, Config) ->
    case erlang:element(3, Config) of
        true ->
            case Level of
                emergency ->
                    red(<<"EMERG"/utf8>>);

                alert ->
                    red(<<"ALERT"/utf8>>);

                critical ->
                    magenta(<<"CRIT"/utf8>>);

                error ->
                    magenta(<<"ERROR"/utf8>>);

                warning ->
                    yellow(<<"WARN"/utf8>>);

                notice ->
                    yellow(<<"NOTICE"/utf8>>);

                info ->
                    green(<<"INFO"/utf8>>);

                debug ->
                    blue(<<"DEBUG"/utf8>>)
            end;

        false ->
            case Level of
                emergency ->
                    <<"EMERG"/utf8>>;

                alert ->
                    <<"ALERT"/utf8>>;

                critical ->
                    <<"CRIT"/utf8>>;

                error ->
                    <<"ERROR"/utf8>>;

                warning ->
                    <<"WARN"/utf8>>;

                notice ->
                    <<"NOTICE"/utf8>>;

                info ->
                    <<"INFO"/utf8>>;

                debug ->
                    <<"DEBUG"/utf8>>
            end
    end.

-file("src/glight.gleam", 161).
-spec std_out(
    logging:log_level(),
    binary(),
    gleam@dict:dict(binary(), binary()),
    log_config()
) -> nil.
std_out(Log_level, Log_msg, Data, Config) ->
    Ts = begin
        _pipe = birl:now(),
        birl:to_time_string(_pipe)
    end,
    Level = begin
        _pipe@1 = (<<<<" ["/utf8,
                (level_to_std_out_string(Log_level, Config))/binary>>/binary,
            "]"/utf8>>),
        gleam@string:pad_end(_pipe@1, 18, <<" "/utf8>>)
    end,
    Msg = <<<<<<Ts/binary, Level/binary>>/binary, " -> "/utf8>>/binary,
        Log_msg/binary>>,
    gleam@io:debug(case maps:size(Data) of
            0 ->
                Msg;

            _ ->
                <<<<Msg/binary, "\n"/utf8>>/binary,
                    (begin
                        _pipe@2 = maps:to_list(Data),
                        _pipe@3 = gleam@list:map(
                            _pipe@2,
                            fun(E) ->
                                Key = erlang:element(1, E),
                                Value = erlang:element(2, E),
                                <<<<<<"\t\t\t\t\t"/utf8, Key/binary>>/binary,
                                        ": "/utf8>>/binary,
                                    Value/binary>>
                            end
                        ),
                        _pipe@4 = gleam@string:join(_pipe@3, <<"\n"/utf8>>),
                        grey(_pipe@4)
                    end)/binary>>
        end),
    nil.

-file("src/glight.gleam", 148).
-spec init_state(list(transport())) -> {ok, state()} | {error, glight_error()}.
init_state(Transports) ->
    _pipe = Transports,
    _pipe@1 = gleam@list:map(_pipe, fun(Transport) -> case Transport of
                console_transport ->
                    {ok, fun std_out/4};

                {file_transport, File} ->
                    file_out(File);

                {custom_transport, Log} ->
                    {ok, Log}
            end end),
    _pipe@2 = gleam@result:all(_pipe@1),
    gleam@result:map(_pipe@2, fun(Field@0) -> {state, Field@0} end).

-file("src/glight.gleam", 20).
?DOC(" configuration\n").
-spec start(list(transport())) -> {ok, log_context()} | {error, glight_error()}.
start(Transports) ->
    _pipe = init_state(Transports),
    _pipe@2 = gleam@result:'try'(
        _pipe,
        fun(State) ->
            _pipe@1 = gleam@otp@actor:start(State, fun handle_message/2),
            gleam@result:map_error(
                _pipe@1,
                fun(Field@0) -> {actor_start_error, Field@0} end
            )
        end
    ),
    gleam@result:'try'(
        _pipe@2,
        fun(Logger) ->
            _pipe@3 = {log_context,
                Logger,
                {log_config, info, true},
                maps:new()},
            {ok, _pipe@3}
        end
    ).

-file("src/glight.gleam", 35).
-spec must_start(list(transport())) -> log_context().
must_start(Transports) ->
    _assert_subject = start(Transports),
    {ok, Logger} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"glight"/utf8>>,
                        function => <<"must_start"/utf8>>,
                        line => 36})
    end,
    Logger.