tobble

-module(tobble@internal@builder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/tobble/internal/builder.gleam").
-export([new/0, from_list/1, from_error/1, to_result/1, set_title/2, add_row/2]).
-export_type([builder/0, built_table/0, builder_internals/0, builder_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.

?MODULEDOC(false).

-opaque builder() :: {builder, builder_internals()} |
    {failed_builder, builder_error()}.

-type built_table() :: {built_table,
        tobble@internal@rows:rows(binary()),
        gleam@option:option(binary())}.

-type builder_internals() :: {builder_internals,
        list(list(binary())),
        gleam@option:option(binary())}.

-type builder_error() :: {inconsistent_column_count_error, integer(), integer()} |
    empty_table_error |
    empty_title_error.

-file("src/tobble/internal/builder.gleam", 31).
?DOC(false).
-spec new() -> builder().
new() ->
    {builder, {builder_internals, [], none}}.

-file("src/tobble/internal/builder.gleam", 64).
?DOC(false).
-spec from_list(list(list(binary()))) -> builder().
from_list(Rows) ->
    {builder, {builder_internals, lists:reverse(Rows), none}}.

-file("src/tobble/internal/builder.gleam", 72).
?DOC(false).
-spec from_error(builder_error()) -> builder().
from_error(Error) ->
    {failed_builder, Error}.

-file("src/tobble/internal/builder.gleam", 76).
?DOC(false).
-spec build_rows(list(list(binary()))) -> {ok,
        tobble@internal@rows:rows(binary())} |
    {error, builder_error()}.
build_rows(Unbuilt_rows) ->
    _pipe = Unbuilt_rows,
    _pipe@1 = lists:reverse(_pipe),
    _pipe@2 = tobble@internal@rows:from_lists(_pipe@1),
    gleam@result:map_error(_pipe@2, fun(Err) -> case Err of
                {inconsistent_lengths_error, Expected, Got} ->
                    {inconsistent_column_count_error, Expected, Got}
            end end).

-file("src/tobble/internal/builder.gleam", 104).
?DOC(false).
-spec finish_build_step({ok, builder_internals()} | {error, builder_error()}) -> builder().
finish_build_step(Build_result) ->
    case Build_result of
        {ok, Internals} ->
            {builder, Internals};

        {error, Error} ->
            {failed_builder, Error}
    end.

-file("src/tobble/internal/builder.gleam", 90).
?DOC(false).
-spec build_on(
    builder(),
    fun((builder_internals()) -> {ok, builder_internals()} |
        {error, builder_error()})
) -> builder().
build_on(Builder, Build) ->
    case Builder of
        {builder, Internals} ->
            _pipe = Internals,
            _pipe@1 = Build(_pipe),
            finish_build_step(_pipe@1);

        {failed_builder, _} ->
            Builder
    end.

-file("src/tobble/internal/builder.gleam", 111).
?DOC(false).
-spec ensure_nonempty_rows(builder()) -> builder().
ensure_nonempty_rows(Builder) ->
    build_on(Builder, fun(Internals) -> case erlang:element(2, Internals) of
                [] ->
                    {error, empty_table_error};

                _ ->
                    {ok, Internals}
            end end).

-file("src/tobble/internal/builder.gleam", 50).
?DOC(false).
-spec to_result(builder()) -> {ok, built_table()} | {error, builder_error()}.
to_result(Builder) ->
    case ensure_nonempty_rows(Builder) of
        {builder, Internals} ->
            gleam@result:'try'(
                build_rows(erlang:element(2, Internals)),
                fun(Built_rows) ->
                    {ok,
                        {built_table, Built_rows, erlang:element(3, Internals)}}
                end
            );

        {failed_builder, Error} ->
            {error, Error}
    end.

-file("src/tobble/internal/builder.gleam", 134).
?DOC(false).
-spec validate_title(
    binary(),
    fun(() -> {ok, builder_internals()} | {error, builder_error()})
) -> {ok, builder_internals()} | {error, builder_error()}.
validate_title(Title, Then) ->
    case Title of
        <<""/utf8>> ->
            {error, empty_title_error};

        _ ->
            Then()
    end.

-file("src/tobble/internal/builder.gleam", 43).
?DOC(false).
-spec set_title(builder(), binary()) -> builder().
set_title(Builder, Title) ->
    build_on(
        Builder,
        fun(Internals) ->
            validate_title(
                Title,
                fun() ->
                    {ok,
                        begin
                            _record = Internals,
                            {builder_internals,
                                erlang:element(2, _record),
                                {some, Title}}
                        end}
                end
            )
        end
    ).

-file("src/tobble/internal/builder.gleam", 141).
?DOC(false).
-spec last_row_column_count(builder_internals()) -> gleam@option:option(integer()).
last_row_column_count(Internals) ->
    _pipe = erlang:element(2, Internals),
    _pipe@1 = gleam@list:first(_pipe),
    _pipe@2 = gleam@option:from_result(_pipe@1),
    gleam@option:map(_pipe@2, fun erlang:length/1).

-file("src/tobble/internal/builder.gleam", 120).
?DOC(false).
-spec validate_column_count(
    builder_internals(),
    list(binary()),
    fun(() -> {ok, builder_internals()} | {error, builder_error()})
) -> {ok, builder_internals()} | {error, builder_error()}.
validate_column_count(Internals, Columns, Then) ->
    Num_columns = erlang:length(Columns),
    case last_row_column_count(Internals) of
        none ->
            Then();

        {some, Expected} when Expected =:= Num_columns ->
            Then();

        {some, Expected@1} ->
            {error, {inconsistent_column_count_error, Expected@1, Num_columns}}
    end.

-file("src/tobble/internal/builder.gleam", 35).
?DOC(false).
-spec add_row(builder(), list(binary())) -> builder().
add_row(Builder, Columns) ->
    build_on(
        Builder,
        fun(Internals) ->
            validate_column_count(
                Internals,
                Columns,
                fun() ->
                    {ok,
                        begin
                            _record = Internals,
                            {builder_internals,
                                [Columns | erlang:element(2, Internals)],
                                erlang:element(3, _record)}
                        end}
                end
            )
        end
    ).