integer_complexity

-module(integer_complexity@expression).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([default_format_options/0, with_padding/2, with_addition_sign/2, with_multiplication_sign/2, with_left_bracket/2, with_right_bracket/2, with_digits/2, evaluate_expression/1, to_string/2]).
-export_type([format_options/6, padding_defined/0, padding_not_defined/0, add_sign_defined/0, add_sign_not_defined/0, multiply_sign_defined/0, multiply_sign_not_defined/0, left_bracket_defined/0, left_bracket_not_defined/0, right_bracket_defined/0, right_bracket_not_defined/0, digits_defined/0, digits_not_defined/0, expression/0]).

-opaque format_options(KAJ, KAK, KAL, KAM, KAN, KAO) :: {format_options,
        binary(),
        binary(),
        binary(),
        binary(),
        binary(),
        gary:erlang_array(binary()),
        integer()} |
    {gleam_phantom, KAJ, KAK, KAL, KAM, KAN, KAO}.

-type padding_defined() :: any().

-type padding_not_defined() :: any().

-type add_sign_defined() :: any().

-type add_sign_not_defined() :: any().

-type multiply_sign_defined() :: any().

-type multiply_sign_not_defined() :: any().

-type left_bracket_defined() :: any().

-type left_bracket_not_defined() :: any().

-type right_bracket_defined() :: any().

-type right_bracket_not_defined() :: any().

-type digits_defined() :: any().

-type digits_not_defined() :: any().

-type expression() :: {add, expression(), expression()} |
    {multiply, expression(), expression()} |
    one.

-spec default_format_options() -> format_options(any(), any(), any(), any(), any(), any()).
default_format_options() ->
    {format_options,
        <<" "/utf8>>,
        <<"+"/utf8>>,
        <<"*"/utf8>>,
        <<"("/utf8>>,
        <<")"/utf8>>,
        integer_complexity@internal@array:from_list([<<"1"/utf8>>], <<""/utf8>>),
        1}.

-spec with_padding(
    format_options(padding_not_defined(), KAQ, KAR, KAS, KAT, KAU),
    binary()
) -> format_options(padding_defined(), KAQ, KAR, KAS, KAT, KAU).
with_padding(Options, Padding) ->
    {format_options,
        Padding,
        erlang:element(3, Options),
        erlang:element(4, Options),
        erlang:element(5, Options),
        erlang:element(6, Options),
        erlang:element(7, Options),
        erlang:element(8, Options)}.

-spec with_addition_sign(
    format_options(KBH, add_sign_not_defined(), KBI, KBJ, KBK, KBL),
    binary()
) -> format_options(KBH, add_sign_defined(), KBI, KBJ, KBK, KBL).
with_addition_sign(Options, Sign) ->
    {format_options,
        erlang:element(2, Options),
        Sign,
        erlang:element(4, Options),
        erlang:element(5, Options),
        erlang:element(6, Options),
        erlang:element(7, Options),
        erlang:element(8, Options)}.

-spec with_multiplication_sign(
    format_options(KBY, KBZ, multiply_sign_not_defined(), KCA, KCB, KCC),
    binary()
) -> format_options(KBY, KBZ, multiply_sign_defined(), KCA, KCB, KCC).
with_multiplication_sign(Options, Sign) ->
    {format_options,
        erlang:element(2, Options),
        erlang:element(3, Options),
        Sign,
        erlang:element(5, Options),
        erlang:element(6, Options),
        erlang:element(7, Options),
        erlang:element(8, Options)}.

-spec with_left_bracket(
    format_options(KCP, KCQ, KCR, left_bracket_not_defined(), KCS, KCT),
    binary()
) -> format_options(KCP, KCQ, KCR, left_bracket_defined(), KCS, KCT).
with_left_bracket(Options, Left_bracket) ->
    {format_options,
        erlang:element(2, Options),
        erlang:element(3, Options),
        erlang:element(4, Options),
        Left_bracket,
        erlang:element(6, Options),
        erlang:element(7, Options),
        erlang:element(8, Options)}.

-spec with_right_bracket(
    format_options(KDG, KDH, KDI, KDJ, right_bracket_not_defined(), KDK),
    binary()
) -> format_options(KDG, KDH, KDI, KDJ, right_bracket_defined(), KDK).
with_right_bracket(Options, Right_bracket) ->
    {format_options,
        erlang:element(2, Options),
        erlang:element(3, Options),
        erlang:element(4, Options),
        erlang:element(5, Options),
        Right_bracket,
        erlang:element(7, Options),
        erlang:element(8, Options)}.

-spec with_digits(
    format_options(KDX, KDY, KDZ, KEA, KEB, digits_not_defined()),
    list(binary())
) -> format_options(KDX, KDY, KDZ, KEA, KEB, digits_defined()).
with_digits(Options, Digits) ->
    {format_options,
        erlang:element(2, Options),
        erlang:element(3, Options),
        erlang:element(4, Options),
        erlang:element(5, Options),
        erlang:element(6, Options),
        integer_complexity@internal@array:from_list(Digits, <<""/utf8>>),
        erlang:length(Digits)}.

-spec conditionally_apply_parens(
    binary(),
    gleam@order:order(),
    format_options(any(), any(), any(), any(), any(), any())
) -> binary().
conditionally_apply_parens(Expression_str, Precidence, Options) ->
    case Precidence of
        lt ->
            <<<<(erlang:element(5, Options))/binary, Expression_str/binary>>/binary,
                (erlang:element(6, Options))/binary>>;

        _ ->
            Expression_str
    end.

-spec evaluate_expression(expression()) -> integer().
evaluate_expression(Expression) ->
    case Expression of
        one ->
            1;

        {add, Lhs, Rhs} ->
            evaluate_expression(Lhs) + evaluate_expression(Rhs);

        {multiply, Lhs@1, Rhs@1} ->
            evaluate_expression(Lhs@1) * evaluate_expression(Rhs@1)
    end.

-spec compare_precidence(expression(), expression()) -> gleam@order:order().
compare_precidence(Lhs, Rhs) ->
    case {Lhs, Rhs} of
        {{add, _, _}, {multiply, _, _}} ->
            lt;

        {{multiply, _, _}, {add, _, _}} ->
            gt;

        {_, _} ->
            eq
    end.

-spec apply_padding(binary(), binary()) -> binary().
apply_padding(Padding, Str) ->
    <<<<Padding/binary, Str/binary>>/binary, Padding/binary>>.

-spec represent_binary_op(
    expression(),
    expression(),
    expression(),
    binary(),
    format_options(any(), any(), any(), any(), any(), any())
) -> binary().
represent_binary_op(This, Lhs, Rhs, Sign, Options) ->
    <<<<(represent_expression(Lhs, compare_precidence(Lhs, This), Options))/binary,
            (apply_padding(erlang:element(2, Options), Sign))/binary>>/binary,
        (represent_expression(Rhs, compare_precidence(Rhs, This), Options))/binary>>.

-spec represent_expression(
    expression(),
    gleam@order:order(),
    format_options(any(), any(), any(), any(), any(), any())
) -> binary().
represent_expression(Expression, Precidence, Options) ->
    Base = erlang:element(8, Options),
    Eval_result = evaluate_expression(Expression),
    case {Eval_result =< Base, Expression} of
        {_, one} ->
            gleam@result:unwrap(
                integer_complexity@internal@array:get(
                    erlang:element(7, Options),
                    Eval_result - 1
                ),
                <<""/utf8>>
            );

        {true, _} ->
            gleam@result:unwrap(
                integer_complexity@internal@array:get(
                    erlang:element(7, Options),
                    Eval_result - 1
                ),
                <<""/utf8>>
            );

        {false, {add, Lhs, Rhs}} ->
            _pipe = represent_binary_op(
                Expression,
                Lhs,
                Rhs,
                erlang:element(3, Options),
                Options
            ),
            conditionally_apply_parens(_pipe, Precidence, Options);

        {false, {multiply, Lhs@1, Rhs@1}} ->
            _pipe@1 = represent_binary_op(
                Expression,
                Lhs@1,
                Rhs@1,
                erlang:element(4, Options),
                Options
            ),
            conditionally_apply_parens(_pipe@1, Precidence, Options)
    end.

-spec to_string(
    expression(),
    format_options(any(), any(), any(), any(), any(), any())
) -> binary().
to_string(Expression, Options) ->
    represent_expression(Expression, eq, Options).