dahlia

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

-export([dahlia/0, with_colors/2, merge_colors/2, with_escape_character/2, convert/2, dprint/2, dprintln/2]).
-export_type([dahlia/0]).

-type dahlia() :: {dahlia,
        gleam@option:option(gleam@map:map_(binary(), dahlia@ansi:ansi())),
        binary()}.

-spec dahlia() -> dahlia().
dahlia() ->
    {dahlia, none, <<"&"/utf8>>}.

-spec with_colors(dahlia(), gleam@map:map_(binary(), dahlia@ansi:ansi())) -> dahlia().
with_colors(D, Colors) ->
    erlang:setelement(2, D, {some, Colors}).

-spec merge_colors(dahlia(), gleam@map:map_(binary(), dahlia@ansi:ansi())) -> dahlia().
merge_colors(D, Colors) ->
    case erlang:element(2, D) of
        {some, Old_colors} ->
            erlang:setelement(2, D, {some, gleam@map:merge(Old_colors, Colors)});

        none ->
            erlang:setelement(2, D, {some, Colors})
    end.

-spec with_escape_character(dahlia(), binary()) -> dahlia().
with_escape_character(D, Escape_character) ->
    erlang:setelement(3, D, Escape_character).

-spec convert_inner(
    list(binary()),
    binary(),
    gleam@map:map_(binary(), dahlia@ansi:ansi())
) -> list(binary()).
convert_inner(Graphemes, Escape_character, Codes) ->
    case Graphemes of
        [] ->
            [];

        [Esc, <<"["/utf8>>, <<"#"/utf8>>, A, B, C, D, E, F, <<"]"/utf8>> | Rest] when Esc =:= Escape_character ->
            _assert_subject = gleam@int:base_parse(<<A/binary, B/binary>>, 16),
            {ok, R} = case _assert_subject of
                {ok, _} -> _assert_subject;
                _assert_fail ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 60})
            end,
            _assert_subject@1 = gleam@int:base_parse(<<C/binary, D/binary>>, 16),
            {ok, G} = case _assert_subject@1 of
                {ok, _} -> _assert_subject@1;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@1,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 61})
            end,
            _assert_subject@2 = gleam@int:base_parse(<<E/binary, F/binary>>, 16),
            {ok, B@1} = case _assert_subject@2 of
                {ok, _} -> _assert_subject@2;
                _assert_fail@2 ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@2,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 62})
            end,
            Ansi = {ansi_color24, R, G, B@1, false},
            serialize_and_build_rest(Ansi, Rest, Escape_character, Codes);

        [Esc@1,
            <<"~"/utf8>>,
            <<"["/utf8>>,
            <<"#"/utf8>>,
            A@1,
            B@2,
            C@1,
            D@1,
            E@1,
            F@1,
            <<"]"/utf8>> |
            Rest@1] when Esc@1 =:= Escape_character ->
            _assert_subject@3 = gleam@int:base_parse(
                <<A@1/binary, B@2/binary>>,
                16
            ),
            {ok, R@1} = case _assert_subject@3 of
                {ok, _} -> _assert_subject@3;
                _assert_fail@3 ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@3,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 68})
            end,
            _assert_subject@4 = gleam@int:base_parse(
                <<C@1/binary, D@1/binary>>,
                16
            ),
            {ok, G@1} = case _assert_subject@4 of
                {ok, _} -> _assert_subject@4;
                _assert_fail@4 ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@4,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 69})
            end,
            _assert_subject@5 = gleam@int:base_parse(
                <<E@1/binary, F@1/binary>>,
                16
            ),
            {ok, B@3} = case _assert_subject@5 of
                {ok, _} -> _assert_subject@5;
                _assert_fail@5 ->
                    erlang:error(#{gleam_error => assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@5,
                                module => <<"dahlia"/utf8>>,
                                function => <<"convert_inner"/utf8>>,
                                line => 70})
            end,
            Ansi@1 = {ansi_color24, R@1, G@1, B@3, true},
            serialize_and_build_rest(Ansi@1, Rest@1, Escape_character, Codes);

        [Esc@2, Code | Rest@2] when Esc@2 =:= Escape_character ->
            case gleam@map:get(Codes, Code) of
                {ok, Ansi@2} ->
                    serialize_and_build_rest(
                        Ansi@2,
                        Rest@2,
                        Escape_character,
                        Codes
                    );

                {error, _} ->
                    gleam@list:append(
                        [Escape_character],
                        convert_inner(
                            gleam@list:append([Code], Rest@2),
                            Escape_character,
                            Codes
                        )
                    )
            end;

        [Head | Tail] ->
            gleam@list:append(
                [Head],
                convert_inner(Tail, Escape_character, Codes)
            )
    end.

-spec convert(dahlia(), binary()) -> binary().
convert(D, Str) ->
    Map@1 = case dahlia@env:get_env(<<"NO_COLOR"/utf8>>) of
        {ok, <<"1"/utf8>>} ->
            gleam@map:new();

        _ ->
            case erlang:element(2, D) of
                {some, Map} ->
                    Map;

                none ->
                    case dahlia@env:get_env(<<"TERM"/utf8>>) of
                        {ok, Env} ->
                            case Env of
                                <<"xterm"/utf8>> ->
                                    dahlia@colors:eight_bit();

                                <<"xterm-256color"/utf8>> ->
                                    dahlia@colors:twentyfour_bit();

                                _ ->
                                    dahlia@colors:three_bit()
                            end;

                        {error, _} ->
                            dahlia@colors:twentyfour_bit()
                    end
            end
    end,
    _pipe = convert_inner(
        gleam@string:to_graphemes(Str),
        erlang:element(3, D),
        Map@1
    ),
    gleam@string:join(_pipe, <<""/utf8>>).

-spec serialize_and_build_rest(
    dahlia@ansi:ansi(),
    list(binary()),
    binary(),
    gleam@map:map_(binary(), dahlia@ansi:ansi())
) -> list(binary()).
serialize_and_build_rest(Ansi, Rest, Escape_character, Codes) ->
    gleam@list:append(
        begin
            _pipe = dahlia@ansi:serialize(Ansi),
            gleam@string:to_graphemes(_pipe)
        end,
        convert_inner(Rest, Escape_character, Codes)
    ).

-spec dprint(dahlia(), binary()) -> nil.
dprint(D, Str) ->
    _pipe = convert(D, Str),
    gleam@io:print(_pipe).

-spec dprintln(dahlia(), binary()) -> nil.
dprintln(D, Str) ->
    _pipe = convert(D, Str),
    gleam@io:println(_pipe).