-module(tobble@internal@rows).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_lists/1, columns/1, pop_row/1, map_rows/2, rowwise_fold/3, map/2, columnwise_fold/3, from_lists/1]).
-export_type([rows/1, rows_error/0, non_empty_list/1]).

-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 rows(NQX) :: {rows, list(list(NQX))}.

-type rows_error() :: {inconsistent_lengths_error, integer(), integer()}.

-type non_empty_list(NQY) :: {non_empty_list, NQY, list(NQY)}.

-file("src/tobble/internal/rows.gleam", 24).
?DOC(false).
-spec to_lists(rows(NRF)) -> list(list(NRF)).
to_lists(Rows) ->
    {rows, Lists} = Rows,
    Lists.

-file("src/tobble/internal/rows.gleam", 30).
?DOC(false).
-spec columns(rows(any())) -> integer().
columns(Rows) ->
    {rows, Lists} = Rows,
    case Lists of
        [] ->
            0;

        [First_list | _] ->
            erlang:length(First_list)
    end.

-file("src/tobble/internal/rows.gleam", 38).
?DOC(false).
-spec pop_row(rows(NRL)) -> {ok, {list(NRL), rows(NRL)}} | {error, nil}.
pop_row(Rows) ->
    case Rows of
        {rows, []} ->
            {error, nil};

        {rows, [Head | Rest]} ->
            {ok, {Head, {rows, Rest}}}
    end.

-file("src/tobble/internal/rows.gleam", 59).
?DOC(false).
-spec map_rows(rows(NRV), fun((list(NRV)) -> NRY)) -> list(NRY).
map_rows(Rows, Func) ->
    {rows, Lists} = Rows,
    gleam@list:map(Lists, Func).

-file("src/tobble/internal/rows.gleam", 48).
?DOC(false).
-spec rowwise_fold(rows(NRR), NRT, fun((NRT, NRR) -> NRT)) -> list(NRT).
rowwise_fold(Rows, Initial_value, Folder) ->
    map_rows(Rows, fun(Row) -> gleam@list:fold(Row, Initial_value, Folder) end).

-file("src/tobble/internal/rows.gleam", 65).
?DOC(false).
-spec map(rows(NSA), fun((NSA) -> NSC)) -> rows(NSC).
map(Rows, Func) ->
    _pipe = map_rows(Rows, fun(Row) -> gleam@list:map(Row, Func) end),
    {rows, _pipe}.

-file("src/tobble/internal/rows.gleam", 116).
?DOC(false).
-spec must_first(list(NSS)) -> NSS.
must_first(List) ->
    [Head | _] = case List of
        [_ | _] -> List;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"tobble/internal/rows"/utf8>>,
                        function => <<"must_first"/utf8>>,
                        line => 117})
    end,
    Head.

-file("src/tobble/internal/rows.gleam", 121).
?DOC(false).
-spec must_rest(list(NSU)) -> list(NSU).
must_rest(List) ->
    [_ | Rest] = case List of
        [_ | _] -> List;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"tobble/internal/rows"/utf8>>,
                        function => <<"must_rest"/utf8>>,
                        line => 122})
    end,
    Rest.

-file("src/tobble/internal/rows.gleam", 95).
?DOC(false).
-spec do_transpose(non_empty_list(list(NSL)), list(list(NSL))) -> list(list(NSL)).
do_transpose(Lists, Acc) ->
    case erlang:element(2, Lists) of
        [] ->
            lists:reverse(Acc);

        _ ->
            Row = [must_first(erlang:element(2, Lists)) |
                gleam@list:map(erlang:element(3, Lists), fun must_first/1)],
            All_rests = {non_empty_list,
                must_rest(erlang:element(2, Lists)),
                gleam@list:map(erlang:element(3, Lists), fun must_rest/1)},
            do_transpose(All_rests, [Row | Acc])
    end.

-file("src/tobble/internal/rows.gleam", 81).
?DOC(false).
-spec transpose(rows(NSI)) -> rows(NSI).
transpose(Rows) ->
    {rows, Lists} = Rows,
    case Lists of
        [] ->
            Rows;

        [Head | Rest] ->
            Non_empty = {non_empty_list, Head, Rest},
            {rows, do_transpose(Non_empty, [])}
    end.

-file("src/tobble/internal/rows.gleam", 71).
?DOC(false).
-spec columnwise_fold(rows(NSE), NSG, fun((NSG, NSE) -> NSG)) -> list(NSG).
columnwise_fold(Rows, Initial_value, Folder) ->
    _pipe = Rows,
    _pipe@1 = transpose(_pipe),
    rowwise_fold(_pipe@1, Initial_value, Folder).

-file("src/tobble/internal/rows.gleam", 137).
?DOC(false).
-spec do_equal_lengths_check(integer(), list(list(any()))) -> {ok, nil} |
    {error, rows_error()}.
do_equal_lengths_check(Last_length, Lists) ->
    case Lists of
        [] ->
            {ok, nil};

        [List] ->
            Got_length = erlang:length(List),
            case Got_length =:= Last_length of
                true ->
                    {ok, nil};

                false ->
                    {error,
                        {inconsistent_lengths_error, Last_length, Got_length}}
            end;

        [List@1 | Rest] ->
            Length = erlang:length(List@1),
            case Length =:= Last_length of
                false ->
                    {error, {inconsistent_lengths_error, Last_length, Length}};

                true ->
                    do_equal_lengths_check(Length, Rest)
            end
    end.

-file("src/tobble/internal/rows.gleam", 126).
?DOC(false).
-spec equal_lengths(list(list(any()))) -> {ok, nil} | {error, rows_error()}.
equal_lengths(Lists) ->
    case Lists of
        [] ->
            {ok, nil};

        [_] ->
            {ok, nil};

        [List | Rest] ->
            Length = erlang:length(List),
            do_equal_lengths_check(Length, Rest)
    end.

-file("src/tobble/internal/rows.gleam", 18).
?DOC(false).
-spec from_lists(list(list(NQZ))) -> {ok, rows(NQZ)} | {error, rows_error()}.
from_lists(Lists) ->
    _pipe = Lists,
    _pipe@1 = equal_lengths(_pipe),
    gleam@result:map(_pipe@1, fun(_) -> {rows, Lists} end).