-module(glitzer@progress).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glitzer/progress.gleam").
-export([char_from_string/1, string_from_char/1, default_bar/0, slim_bar/0, fancy_slim_bar/0, fancy_slim_arrow_bar/0, thick_bar/0, fancy_thick_bar/0, new_bar/0, with_left_text/2, with_right_text/2, with_empty/2, with_fill/2, with_fill_finished/2, with_fill_head/2, with_fill_head_finished/2, with_newline_on_finished/2, with_length/2, tick/1, tick_by/2, finish/1, print_bar/1, get_raw_bar/1, map_yielder/3, map2_yielder/4, each_yielder/3]).
-export_type([char_/0, state/0, progress_style/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.

-opaque char_() :: {char, binary()}.

-opaque state() :: {state, integer(), boolean()}.

-opaque progress_style() :: {progress_style,
        binary(),
        binary(),
        char_(),
        char_(),
        gleam@option:option(char_()),
        gleam@option:option(char_()),
        gleam@option:option(char_()),
        boolean(),
        integer(),
        state()}.

-file("src/glitzer/progress.gleam", 80).
?DOC(
    " Create a `Char` from a `String`. Returns a `Char` with the given string if\n"
    " the strings length is equal to one and a `Char` of \"#\" otherwise.\n"
    "\n"
    " <details>\n"
    " <summary>Example:</summary>\n"
    "\n"
    " ```gleam\n"
    " import glitzer/progress\n"
    "\n"
    " fn example() {\n"
    "   let char = progress.char_from_string(\"A\")\n"
    " }\n"
    " ```\n"
    "\n"
    " </details>\n"
).
-spec char_from_string(binary()) -> char_().
char_from_string(In) ->
    Len = string:length(In),
    case Len of
        1 ->
            {char, In};

        _ ->
            {char, <<"#"/utf8>>}
    end.

-file("src/glitzer/progress.gleam", 90).
?DOC(" Create a `String` from a given `Char`.\n").
-spec string_from_char(char_()) -> binary().
string_from_char(In) ->
    erlang:element(2, In).

-file("src/glitzer/progress.gleam", 117).
?DOC(" Create and return a default progress bar.\n").
-spec default_bar() -> progress_style().
default_bar() ->
    {progress_style,
        <<"["/utf8>>,
        <<"]"/utf8>>,
        {char, <<" "/utf8>>},
        {char, <<"#"/utf8>>},
        none,
        none,
        none,
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 133).
?DOC(" Create and return a fancy and slim progress bar (inspired by pip).\n").
-spec slim_bar() -> progress_style().
slim_bar() ->
    Sym = <<"\x{2014}"/utf8>>,
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, <<" "/utf8>>},
        {char, Sym},
        none,
        none,
        none,
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 150).
?DOC(" Create and return a fancy and slim progress bar (inspired by pip).\n").
-spec fancy_slim_bar() -> progress_style().
fancy_slim_bar() ->
    Sym = <<"\x{2014}"/utf8>>,
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, gleam_community@ansi:blue(Sym)},
        {char, gleam_community@ansi:red(Sym)},
        {some, {char, gleam_community@ansi:green(Sym)}},
        none,
        none,
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 167).
?DOC(" Create and return a fancy and slim progress bar with an arrow head.\n").
-spec fancy_slim_arrow_bar() -> progress_style().
fancy_slim_arrow_bar() ->
    Sym = <<"\x{2014}"/utf8>>,
    Sym_head = <<"\x{2192}"/utf8>>,
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, gleam_community@ansi:blue(Sym)},
        {char, gleam_community@ansi:red(Sym)},
        {some, {char, gleam_community@ansi:green(Sym)}},
        {some, {char, gleam_community@ansi:red(Sym_head)}},
        {some, {char, gleam_community@ansi:green(Sym_head)}},
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 185).
?DOC(" Create and return a thick bar.\n").
-spec thick_bar() -> progress_style().
thick_bar() ->
    Sym = <<"\x{2588}"/utf8>>,
    Empty_sym = <<"\x{2592}"/utf8>>,
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, Empty_sym},
        {char, Sym},
        none,
        none,
        none,
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 203).
?DOC(" Create and return a fancy thick bar.\n").
-spec fancy_thick_bar() -> progress_style().
fancy_thick_bar() ->
    Sym = <<"\x{2588}"/utf8>>,
    Empty_sym = <<"\x{2592}"/utf8>>,
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, gleam_community@ansi:blue(Empty_sym)},
        {char, gleam_community@ansi:red(Sym)},
        {some, {char, gleam_community@ansi:green(Sym)}},
        none,
        none,
        true,
        100,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 240).
?DOC(
    " Create a new (completely empty) progress bar.\n"
    "\n"
    " <details>\n"
    " <summary>Example:</summary>\n"
    "\n"
    " ```gleam\n"
    " import glitzer/progress\n"
    "\n"
    " fn example() {\n"
    "   let bar = \n"
    "     progress.new_bar()\n"
    "     |> progress.with_length(50)\n"
    "     |> progress.with_left_text(\"Progress: \")\n"
    "     |> progress.with_fill(progress.char_from_string(\"+\"))\n"
    " }\n"
    " ```\n"
    "\n"
    " </details>\n"
).
-spec new_bar() -> progress_style().
new_bar() ->
    {progress_style,
        <<""/utf8>>,
        <<""/utf8>>,
        {char, <<" "/utf8>>},
        {char, <<" "/utf8>>},
        none,
        none,
        none,
        true,
        0,
        {state, 0, false}}.

-file("src/glitzer/progress.gleam", 256).
?DOC(" Add left text to a progress bar.\n").
-spec with_left_text(progress_style(), binary()) -> progress_style().
with_left_text(Bar, Text) ->
    _record = Bar,
    {progress_style,
        Text,
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 264).
?DOC(" Add right text to a progress bar.\n").
-spec with_right_text(progress_style(), binary()) -> progress_style().
with_right_text(Bar, Text) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        Text,
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 273).
?DOC(
    " Add a character to a progress bar that is used to represent the\n"
    " \"background\" of the bar.\n"
).
-spec with_empty(progress_style(), char_()) -> progress_style().
with_empty(Bar, Char) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        Char,
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 279).
?DOC(
    " Add a character to a progress bar that is used to fill the bar on each\n"
    " tick.\n"
).
-spec with_fill(progress_style(), char_()) -> progress_style().
with_fill(Bar, Char) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Char,
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 284).
?DOC(" Add a character that will be used instead of `fill` if the bar is finished.\n").
-spec with_fill_finished(progress_style(), char_()) -> progress_style().
with_fill_finished(Bar, Char) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        {some, Char},
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 292).
?DOC(" Add a head to the progress bar.\n").
-spec with_fill_head(progress_style(), char_()) -> progress_style().
with_fill_head(Bar, Char) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        {some, Char},
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 298).
?DOC(
    " Add a head to the progress bar that will be displayed when the bar\n"
    " finishes.\n"
).
-spec with_fill_head_finished(progress_style(), char_()) -> progress_style().
with_fill_head_finished(Bar, Char) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        {some, Char},
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 305).
-spec with_newline_on_finished(progress_style(), boolean()) -> progress_style().
with_newline_on_finished(Bar, N) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        N,
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 313).
?DOC(" Add length to a progress bar.\n").
-spec with_length(progress_style(), integer()) -> progress_style().
with_length(Bar, Len) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        Len,
        erlang:element(11, _record)}.

-file("src/glitzer/progress.gleam", 318).
?DOC(" Increase the progress of the bar by one.\n").
-spec tick(progress_style()) -> progress_style().
tick(Bar) ->
    case erlang:element(2, erlang:element(11, Bar)) < (erlang:element(10, Bar) + 1) of
        true ->
            _record = Bar,
            {progress_style,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record),
                begin
                    _record@1 = erlang:element(11, Bar),
                    {state,
                        erlang:element(2, erlang:element(11, Bar)) + 1,
                        erlang:element(3, _record@1)}
                end};

        false ->
            _record@2 = Bar,
            {progress_style,
                erlang:element(2, _record@2),
                erlang:element(3, _record@2),
                erlang:element(4, _record@2),
                erlang:element(5, _record@2),
                erlang:element(6, _record@2),
                erlang:element(7, _record@2),
                erlang:element(8, _record@2),
                erlang:element(9, _record@2),
                erlang:element(10, _record@2),
                {state, erlang:element(2, erlang:element(11, Bar)) + 1, true}}
    end.

-file("src/glitzer/progress.gleam", 334).
?DOC(" Increase the progress of the bar by `i`.\n").
-spec tick_by(progress_style(), integer()) -> progress_style().
tick_by(Bar, I) ->
    case I > 0 of
        true ->
            Bar@1 = tick(Bar),
            tick_by(Bar@1, I - 1);

        false ->
            Bar
    end.

-file("src/glitzer/progress.gleam", 345).
?DOC(" Completely fill the progress bar.\n").
-spec finish(progress_style()) -> progress_style().
finish(Bar) ->
    _record = Bar,
    {progress_style,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        {state, erlang:element(10, Bar) + 1, true}}.

-file("src/glitzer/progress.gleam", 444).
-spec get_finished_head_fill(gleam@string_tree:string_tree(), progress_style()) -> gleam@string_tree:string_tree().
get_finished_head_fill(Fill, Bar) ->
    case erlang:element(3, erlang:element(11, Bar)) of
        true ->
            gleam@string_tree:append(
                Fill,
                erlang:element(
                    2,
                    gleam@option:unwrap(
                        erlang:element(8, Bar),
                        gleam@option:unwrap(
                            erlang:element(7, Bar),
                            gleam@option:unwrap(
                                erlang:element(6, Bar),
                                erlang:element(5, Bar)
                            )
                        )
                    )
                )
            );

        false ->
            gleam@string_tree:append(
                Fill,
                erlang:element(
                    2,
                    gleam@option:unwrap(
                        erlang:element(7, Bar),
                        erlang:element(5, Bar)
                    )
                )
            )
    end.

-file("src/glitzer/progress.gleam", 467).
-spec get_finished_fill(gleam@string_tree:string_tree(), progress_style()) -> gleam@string_tree:string_tree().
get_finished_fill(Fill, Bar) ->
    case erlang:element(3, erlang:element(11, Bar)) of
        true ->
            gleam@string_tree:append(
                Fill,
                erlang:element(
                    2,
                    gleam@option:unwrap(
                        erlang:element(6, Bar),
                        erlang:element(5, Bar)
                    )
                )
            );

        false ->
            gleam@string_tree:append(
                Fill,
                erlang:element(2, erlang:element(5, Bar))
            )
    end.

-file("src/glitzer/progress.gleam", 421).
-spec build_progress_fill(
    gleam@string_tree:string_tree(),
    progress_style(),
    integer(),
    integer()
) -> gleam@string_tree:string_tree().
build_progress_fill(Fill, Bar, Left_nonempty, Count) ->
    Fill@1 = case Left_nonempty > 0 of
        true ->
            case Left_nonempty =:= 1 of
                true ->
                    get_finished_head_fill(Fill, Bar);

                false ->
                    get_finished_fill(Fill, Bar)
            end;

        false ->
            gleam@string_tree:append(
                Fill,
                erlang:element(2, erlang:element(4, Bar))
            )
    end,
    case erlang:element(10, Bar) > Count of
        true ->
            build_progress_fill(Fill@1, Bar, Left_nonempty - 1, Count + 1);

        false ->
            Fill@1
    end.

-file("src/glitzer/progress.gleam", 377).
?DOC(
    " Print the progress bar to stderr.\n"
    "\n"
    " <details>\n"
    " <summary>Example:</summary>\n"
    "\n"
    " ```gleam\n"
    " import glitzer/progress\n"
    "\n"
    " fn example() {\n"
    "   let bar = progress.default_bar()\n"
    "\n"
    "   run_example(bar, 0)\n"
    " }\n"
    "\n"
    " fn run_example(bar, count) {\n"
    "   case count < 100 {\n"
    "     True -> {\n"
    "       let bar = progress.tick(bar)\n"
    "       // do some awesome stuff :3\n"
    "       progress.print_bar(bar)\n"
    "       run_example(bar, count + 1)\n"
    "     }\n"
    "     False -> Nil\n"
    "   }\n"
    " }\n"
    " ```\n"
    "\n"
    " </details>\n"
).
-spec print_bar(progress_style()) -> nil.
print_bar(Bar) ->
    Bar@1 = begin
        _record = Bar,
        {progress_style,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            erlang:element(7, _record),
            erlang:element(8, _record),
            erlang:element(9, _record),
            erlang:element(10, _record),
            begin
                _record@1 = erlang:element(11, Bar),
                {state,
                    erlang:element(2, _record@1),
                    erlang:element(2, erlang:element(11, Bar)) >= erlang:element(
                        10,
                        Bar
                    )}
            end}
    end,
    Fill = begin
        _pipe = build_progress_fill(
            gleam@string_tree:new(),
            Bar@1,
            erlang:element(2, erlang:element(11, Bar@1)) + 1,
            0
        ),
        unicode:characters_to_binary(_pipe)
    end,
    End = case erlang:element(3, erlang:element(11, Bar@1)) of
        true ->
            <<"\n"/utf8, (<<"\x{001b}[?25h"/utf8>>)/binary>>;

        false ->
            <<""/utf8>>
    end,
    gleam_stdlib:print_error(
        <<<<<<<<<<<<(<<"\x{001b}[?25l"/utf8>>)/binary,
                                (<<"\x{001b}[2K"/utf8>>)/binary>>/binary,
                            (<<"\r"/utf8>>)/binary>>/binary,
                        (erlang:element(2, Bar@1))/binary>>/binary,
                    Fill/binary>>/binary,
                (erlang:element(3, Bar@1))/binary>>/binary,
            End/binary>>
    ).

-file("src/glitzer/progress.gleam", 403).
-spec get_raw_bar(progress_style()) -> binary().
get_raw_bar(Bar) ->
    Bar@1 = begin
        _record = Bar,
        {progress_style,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            erlang:element(7, _record),
            erlang:element(8, _record),
            erlang:element(9, _record),
            erlang:element(10, _record),
            begin
                _record@1 = erlang:element(11, Bar),
                {state,
                    erlang:element(2, _record@1),
                    erlang:element(2, erlang:element(11, Bar)) >= erlang:element(
                        10,
                        Bar
                    )}
            end}
    end,
    Fill = begin
        _pipe = build_progress_fill(
            gleam@string_tree:new(),
            Bar@1,
            erlang:element(2, erlang:element(11, Bar@1)) + 1,
            0
        ),
        unicode:characters_to_binary(_pipe)
    end,
    End = case erlang:element(3, erlang:element(11, Bar@1)) andalso erlang:element(
        9,
        Bar@1
    ) of
        true ->
            <<"\n"/utf8>>;

        false ->
            <<""/utf8>>
    end,
    <<<<<<(erlang:element(2, Bar@1))/binary, Fill/binary>>/binary,
            (erlang:element(3, Bar@1))/binary>>/binary,
        End/binary>>.

-file("src/glitzer/progress.gleam", 509).
-spec tick_bar_by_i(progress_style(), integer()) -> progress_style().
tick_bar_by_i(Bar, I) ->
    case I > 0 of
        true ->
            tick_bar_by_i(tick(Bar), I - 1);

        false ->
            Bar
    end.

-file("src/glitzer/progress.gleam", 496).
?DOC(
    " Map a yielder to a function with a bar that ticks every run of the\n"
    " function.\n"
    "\n"
    " <details>\n"
    " <summary>Example:</summary>\n"
    "\n"
    " ```gleam\n"
    " import glitzer/progress\n"
    "\n"
    " fn example(bar) {\n"
    "   yielder.range(0, 100)\n"
    "   |> progress.map_yielder(fn(bar, element) {\n"
    "     progress.print_bar(bar)\n"
    "     // do some heavy calculations here >:)\n"
    "   })\n"
    " }\n"
    " ```\n"
    "\n"
    " </details>\n"
).
-spec map_yielder(
    gleam@yielder:yielder(LVV),
    progress_style(),
    fun((progress_style(), LVV) -> LVX)
) -> gleam@yielder:yielder(LVX).
map_yielder(Y, Bar, Fun) ->
    _pipe = gleam@yielder:index(Y),
    gleam@yielder:map(
        _pipe,
        fun(Pair) ->
            {El, I} = Pair,
            _pipe@1 = tick_bar_by_i(Bar, I),
            Fun(_pipe@1, El)
        end
    ).

-file("src/glitzer/progress.gleam", 516).
-spec map2_yielder(
    gleam@yielder:yielder(LWB),
    gleam@yielder:yielder(LWD),
    progress_style(),
    fun((progress_style(), LWB, LWD) -> LWF)
) -> gleam@yielder:yielder(LWF).
map2_yielder(Y1, Y2, Bar, Fun) ->
    _pipe = gleam@yielder:zip(Y1, Y2),
    _pipe@1 = gleam@yielder:index(_pipe),
    gleam@yielder:map(
        _pipe@1,
        fun(Pair) ->
            {Pair@1, I} = Pair,
            {El1, El2} = Pair@1,
            _pipe@2 = tick_bar_by_i(Bar, I),
            Fun(_pipe@2, El1, El2)
        end
    ).

-file("src/glitzer/progress.gleam", 532).
-spec each_yielder(
    gleam@yielder:yielder(LWH),
    progress_style(),
    fun((progress_style(), LWH) -> any())
) -> nil.
each_yielder(Y, Bar, Fun) ->
    _pipe = gleam@yielder:index(Y),
    gleam@yielder:each(
        _pipe,
        fun(Pair) ->
            {El, I} = Pair,
            _pipe@1 = tick_bar_by_i(Bar, I),
            Fun(_pipe@1, El)
        end
    ).