dahlia

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

-export([new/0, with_colors/2, merge_colors/2, with_escape_character/2, convert/2, print/2, println/2, reset/1, main/0]).
-export_type([dahlia/0]).

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

-spec new() -> dahlia().
new() ->
    {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 unwrap_assert({ok, FNB} | {error, any()}) -> FNB.
unwrap_assert(Result) ->
    {ok, A} = case Result of
        {ok, _} -> Result;
        _assert_fail ->
            erlang:error(#{gleam_error => assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"dahlia"/utf8>>,
                        function => <<"unwrap_assert"/utf8>>,
                        line => 194})
    end,
    A.

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

        [<<"\\"/utf8>>, Esc | Rest] when Esc =:= Escape_character ->
            gleam@list:append(
                [Esc],
                convert_inner(Rest, Escape_character, Codes)
            );

        [Esc@1,
            <<"["/utf8>>,
            <<"#"/utf8>>,
            A,
            B,
            C,
            D,
            E,
            F,
            <<"]"/utf8>> |
            Rest@1] when Esc@1 =:= Escape_character ->
            _assert_subject = dahlia@ansi:from_hex(
                <<<<<<<<<<<<"#"/utf8, A/binary>>/binary, B/binary>>/binary,
                                C/binary>>/binary,
                            D/binary>>/binary,
                        E/binary>>/binary,
                    F/binary>>
            ),
            {ok, Ansi} = 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,
            serialize_and_build_rest(
                Ansi,
                false,
                Rest@1,
                Escape_character,
                Codes
            );

        [Esc@2,
            <<"~"/utf8>>,
            <<"["/utf8>>,
            <<"#"/utf8>>,
            A@1,
            B@1,
            C@1,
            D@1,
            E@1,
            F@1,
            <<"]"/utf8>> |
            Rest@2] when Esc@2 =:= Escape_character ->
            _assert_subject@1 = dahlia@ansi:from_hex(
                <<<<<<<<<<<<"#"/utf8, A@1/binary>>/binary, B@1/binary>>/binary,
                                C@1/binary>>/binary,
                            D@1/binary>>/binary,
                        E@1/binary>>/binary,
                    F@1/binary>>
            ),
            {ok, Ansi@1} = 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 => 64})
            end,
            serialize_and_build_rest(
                Ansi@1,
                true,
                Rest@2,
                Escape_character,
                Codes
            );

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

                {error, _} ->
                    gleam@list:append(
                        [Escape_character],
                        convert_inner(
                            gleam@list:append([<<"~"/utf8>>, Code], Rest@3),
                            Escape_character,
                            Codes
                        )
                    )
            end;

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

                {error, _} ->
                    gleam@list:append(
                        [Escape_character],
                        convert_inner(
                            gleam@list:append([Code@1], Rest@4),
                            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@internal@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@internal@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(),
    boolean(),
    list(binary()),
    binary(),
    gleam@map:map_(binary(), dahlia@ansi:ansi())
) -> list(binary()).
serialize_and_build_rest(Ansi, Background, Rest, Escape_character, Codes) ->
    gleam@list:append(
        begin
            _pipe = dahlia@ansi:serialize(Ansi, Background),
            gleam@string:to_graphemes(_pipe)
        end,
        convert_inner(Rest, Escape_character, Codes)
    ).

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

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

-spec reset(dahlia()) -> dahlia().
reset(D) ->
    _pipe = new(),
    print(_pipe, <<"&r"/utf8>>),
    D.

-spec main() -> dahlia().
main() ->
    _pipe = new(),
    _pipe@7 = with_colors(
        _pipe,
        begin
            _pipe@1 = gleam@map:new(),
            _pipe@3 = gleam@map:insert(
                _pipe@1,
                <<"P"/utf8>>,
                begin
                    _pipe@2 = dahlia@ansi:from_hex(<<"#5BCEFA"/utf8>>),
                    unwrap_assert(_pipe@2)
                end
            ),
            _pipe@5 = gleam@map:insert(
                _pipe@3,
                <<"B"/utf8>>,
                begin
                    _pipe@4 = dahlia@ansi:from_hex(<<"#F5A9B8"/utf8>>),
                    unwrap_assert(_pipe@4)
                end
            ),
            gleam@map:insert(
                _pipe@5,
                <<"W"/utf8>>,
                begin
                    _pipe@6 = dahlia@ansi:from_hex(<<"#FFFFFF"/utf8>>),
                    unwrap_assert(_pipe@6)
                end
            )
        end
    ),
    _pipe@8 = println(
        _pipe@7,
        <<"&P██████████████████"/utf8>>
    ),
    _pipe@9 = println(
        _pipe@8,
        <<"&B██████████████████"/utf8>>
    ),
    _pipe@10 = println(
        _pipe@9,
        <<"&W██████████████████"/utf8>>
    ),
    _pipe@11 = println(
        _pipe@10,
        <<"&B██████████████████"/utf8>>
    ),
    println(
        _pipe@11,
        <<"&P██████████████████"/utf8>>
    ).