-module(the_stars@log).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/the_stars/log.gleam").
-export([default_tags/0, default_styles/0, new/0, get_level/1, set_level/2, get_style/2, set_style/3, get_tag/2, set_tags/3, get_prefix_fn/1, set_prefix_fn/2, log/3]).
-export_type([log_level/0, logger/0]).

-type log_level() :: debug | info | warn | error | fatal.

-opaque logger() :: {logger,
        log_level(),
        gleam@dict:dict(log_level(), binary()),
        gleam@dict:dict(log_level(), the_stars@styles:style()),
        fun(() -> binary())}.

-file("src/the_stars/log.gleam", 15).
-spec log_level_val(log_level()) -> integer().
log_level_val(Level) ->
    case Level of
        debug ->
            0;

        info ->
            1;

        warn ->
            2;

        error ->
            3;

        fatal ->
            4
    end.

-file("src/the_stars/log.gleam", 47).
-spec default_tags() -> gleam@dict:dict(log_level(), binary()).
default_tags() ->
    Def_tags = [{debug, <<" D "/utf8>>},
        {info, <<" I "/utf8>>},
        {warn, <<" W "/utf8>>},
        {error, <<" E "/utf8>>},
        {fatal, <<" F "/utf8>>}],
    maps:from_list(Def_tags).

-file("src/the_stars/log.gleam", 61).
-spec default_styles() -> gleam@dict:dict(log_level(), the_stars@styles:style()).
default_styles() ->
    Style = begin
        _pipe = the_stars@styles:new(),
        the_stars@styles:set_bold(_pipe, true)
    end,
    Create_style = fun(Fg_hex, Bg_hex) ->
        Fg@1 = case the_stars@color:new_from_hex(Fg_hex) of
            {ok, Fg} -> Fg;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"the_stars/log"/utf8>>,
                            function => <<"default_styles"/utf8>>,
                            line => 67,
                            value => _assert_fail,
                            start => 1443,
                            'end' => 1489,
                            pattern_start => 1454,
                            pattern_end => 1460})
        end,
        Bg@1 = case the_stars@color:new_from_hex(Bg_hex) of
            {ok, Bg} -> Bg;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"the_stars/log"/utf8>>,
                            function => <<"default_styles"/utf8>>,
                            line => 68,
                            value => _assert_fail@1,
                            start => 1494,
                            'end' => 1540,
                            pattern_start => 1505,
                            pattern_end => 1511})
        end,
        _pipe@1 = Style,
        _pipe@2 = the_stars@styles:set_foreground(_pipe@1, Fg@1),
        the_stars@styles:set_background(_pipe@2, Bg@1)
    end,
    Debug_style = Create_style(<<"#FFFFFF"/utf8>>, <<"#414868"/utf8>>),
    Info_style = Create_style(<<"#FFFFFF"/utf8>>, <<"#485E30"/utf8>>),
    Warn_style = Create_style(<<"#FFFFFF"/utf8>>, <<"#FF9E64"/utf8>>),
    Error_style = Create_style(<<"#FFFFFF"/utf8>>, <<"#F7768E"/utf8>>),
    Fatal_style = Create_style(<<"#FFFFFF"/utf8>>, <<"#BB9AF7"/utf8>>),
    Def_styles = [{debug, Debug_style},
        {info, Info_style},
        {warn, Warn_style},
        {error, Error_style},
        {fatal, Fatal_style}],
    maps:from_list(Def_styles).

-file("src/the_stars/log.gleam", 41).
-spec new() -> logger().
new() ->
    {logger, info, default_tags(), default_styles(), fun() -> <<""/utf8>> end}.

-file("src/the_stars/log.gleam", 91).
-spec get_level(logger()) -> log_level().
get_level(Logger) ->
    erlang:element(2, Logger).

-file("src/the_stars/log.gleam", 95).
-spec set_level(logger(), log_level()) -> logger().
set_level(Logger, Level) ->
    {logger,
        Level,
        erlang:element(3, Logger),
        erlang:element(4, Logger),
        erlang:element(5, Logger)}.

-file("src/the_stars/log.gleam", 99).
-spec get_style(logger(), log_level()) -> the_stars@styles:style().
get_style(Logger, Level) ->
    Style@1 = case gleam_stdlib:map_get(erlang:element(4, Logger), Level) of
        {ok, Style} -> Style;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"the_stars/log"/utf8>>,
                        function => <<"get_style"/utf8>>,
                        line => 103,
                        value => _assert_fail,
                        start => 2458,
                        'end' => 2511,
                        pattern_start => 2469,
                        pattern_end => 2478})
    end,
    Style@1.

-file("src/the_stars/log.gleam", 107).
-spec set_style(logger(), log_level(), the_stars@styles:style()) -> logger().
set_style(Logger, Level, Style) ->
    New_styles = gleam@dict:insert(erlang:element(4, Logger), Level, Style),
    {logger,
        erlang:element(2, Logger),
        erlang:element(3, Logger),
        New_styles,
        erlang:element(5, Logger)}.

-file("src/the_stars/log.gleam", 112).
-spec get_tag(logger(), log_level()) -> binary().
get_tag(Logger, Level) ->
    Style@1 = case gleam_stdlib:map_get(erlang:element(3, Logger), Level) of
        {ok, Style} -> Style;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"the_stars/log"/utf8>>,
                        function => <<"get_tag"/utf8>>,
                        line => 116,
                        value => _assert_fail,
                        start => 2908,
                        'end' => 2959,
                        pattern_start => 2919,
                        pattern_end => 2928})
    end,
    Style@1.

-file("src/the_stars/log.gleam", 120).
-spec set_tags(logger(), log_level(), binary()) -> logger().
set_tags(Logger, Level, Tag) ->
    New_tags = gleam@dict:insert(erlang:element(3, Logger), Level, Tag),
    {logger,
        erlang:element(2, Logger),
        New_tags,
        erlang:element(4, Logger),
        erlang:element(5, Logger)}.

-file("src/the_stars/log.gleam", 125).
-spec get_prefix_fn(logger()) -> fun(() -> binary()).
get_prefix_fn(Logger) ->
    erlang:element(5, Logger).

-file("src/the_stars/log.gleam", 129).
-spec set_prefix_fn(logger(), fun(() -> binary())) -> logger().
set_prefix_fn(Logger, Prefix_fn) ->
    {logger,
        erlang:element(2, Logger),
        erlang:element(3, Logger),
        erlang:element(4, Logger),
        Prefix_fn}.

-file("src/the_stars/log.gleam", 135).
-spec log(logger(), log_level(), binary()) -> nil.
log(Logger, Level, Value) ->
    case log_level_val(erlang:element(2, Logger)) =< log_level_val(Level) of
        true ->
            _pipe = (<<<<<<(begin
                            S = (erlang:element(5, Logger))(),
                            case string:length(S) > 0 of
                                true ->
                                    <<S/binary, " "/utf8>>;

                                false ->
                                    <<""/utf8>>
                            end
                        end)/binary,
                        (the_stars@styles:render(
                            get_style(Logger, Level),
                            get_tag(Logger, Level)
                        ))/binary>>/binary,
                    " "/utf8>>/binary,
                Value/binary>>),
            gleam_stdlib:println(_pipe);

        false ->
            nil
    end.