-module(chomp@pratt).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([sub_expression/2, expression/3, prefix_custom/3, prefix/3, infix_custom/3, infix/3, postfix_custom/3, postfix/3, operator_custom/1]).
-export_type([config/4, operator/4, precedence/0]).

-opaque config(IPP, IPQ, IPR, IPS) :: {config,
        list(fun((config(IPP, IPQ, IPR, IPS)) -> chomp:parser(IPP, IPQ, IPR, IPS))),
        IPQ,
        list(operator(IPP, IPQ, IPR, IPS))}.

-opaque operator(IPT, IPU, IPV, IPW) :: {operator,
        fun((config(IPT, IPU, IPV, IPW)) -> {integer(),
            fun((IPT) -> chomp:parser(IPT, IPU, IPV, IPW))})}.

-type precedence() :: {left, integer()} | {right, integer()}.

-spec operation(IRF, config(IRF, IRG, IRH, IRI), integer()) -> chomp:parser(IRF, IRG, IRH, IRI).
operation(Expr, Config, Current_precedence) ->
    _pipe = erlang:element(4, Config),
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(Operator) ->
            {operator, Op} = Operator,
            case Op(Config) of
                {Precedence, Parser} when Precedence > Current_precedence ->
                    {ok, Parser(Expr)};

                _ ->
                    {error, nil}
            end
        end
    ),
    chomp:one_of(_pipe@1).

-spec sub_expression(config(IQT, IQU, IQV, IQW), integer()) -> chomp:parser(IQT, IQU, IQV, IQW).
sub_expression(Config, Precedence) ->
    Expr = (chomp:lazy(fun() -> _pipe = erlang:element(2, Config),
            _pipe@1 = gleam@list:map(_pipe, fun(P) -> P(Config) end),
            _pipe@2 = chomp:one_of(_pipe@1),
            chomp:or_error(_pipe@2, erlang:element(3, Config)) end)),
    Go = fun(Expr@1) ->
        chomp:one_of(
            [begin
                    _pipe@3 = operation(Expr@1, Config, Precedence),
                    chomp:map(_pipe@3, fun(Field@0) -> {continue, Field@0} end)
                end,
                begin
                    _pipe@4 = chomp:return(Expr@1),
                    chomp:map(_pipe@4, fun(Field@0) -> {break, Field@0} end)
                end]
        )
    end,
    chomp:do(Expr, fun(E) -> chomp:loop(E, Go) end).

-spec expression(
    list(fun((config(IPX, IPY, IPZ, IQA)) -> chomp:parser(IPX, IPY, IPZ, IQA))),
    IPY,
    list(operator(IPX, IPY, IPZ, IQA))
) -> chomp:parser(IPX, IPY, IPZ, IQA).
expression(First, Or_error, Then) ->
    Config = {config, First, Or_error, Then},
    sub_expression(Config, 0).

-spec prefix_custom(
    integer(),
    fun((config(ISI, ISJ, ISK, ISL)) -> chomp:parser(ISQ, ISJ, ISK, ISL)),
    fun((ISI, ISQ) -> ISI)
) -> fun((config(ISI, ISJ, ISK, ISL)) -> chomp:parser(ISI, ISJ, ISK, ISL)).
prefix_custom(Precedence, Operator, Apply) ->
    fun(Config) ->
        chomp:do(
            Operator(Config),
            fun(Op) ->
                chomp:do(
                    sub_expression(Config, Precedence),
                    fun(Subexpr) -> chomp:return(Apply(Subexpr, Op)) end
                )
            end
        )
    end.

-spec prefix(integer(), chomp:parser(any(), IRS, IRT, IRU), fun((IRZ) -> IRZ)) -> fun((config(IRZ, IRS, IRT, IRU)) -> chomp:parser(IRZ, IRS, IRT, IRU)).
prefix(Precedence, Operator, Apply) ->
    prefix_custom(Precedence, fun(_) -> Operator end, fun(A, _) -> Apply(A) end).

-spec infix_custom(
    precedence(),
    fun((config(ITQ, ITR, ITS, ITT)) -> chomp:parser(ITY, ITR, ITS, ITT)),
    fun((ITQ, ITQ, ITY) -> ITQ)
) -> operator(ITQ, ITR, ITS, ITT).
infix_custom(Precedence, Operator, Apply) ->
    {Left_precedence, Right_precedence} = case Precedence of
        {left, P} ->
            {P, P};

        {right, P@1} ->
            {P@1, P@1 - 1}
    end,
    {operator,
        fun(Config) ->
            {Left_precedence,
                fun(Lhs) ->
                    chomp:do(
                        Operator(Config),
                        fun(Op) ->
                            chomp:do(
                                sub_expression(Config, Right_precedence),
                                fun(Subexpr) ->
                                    chomp:return(Apply(Lhs, Subexpr, Op))
                                end
                            )
                        end
                    )
                end}
        end}.

-spec infix(
    precedence(),
    chomp:parser(any(), ITE, ITF, ITG),
    fun((ITL, ITL) -> ITL)
) -> operator(ITL, ITE, ITF, ITG).
infix(Precedence, Operator, Apply) ->
    infix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, B, _) -> Apply(A, B) end
    ).

-spec postfix_custom(
    integer(),
    fun((config(IUU, IUV, IUW, IUX)) -> chomp:parser(IVC, IUV, IUW, IUX)),
    fun((IUU, IVC) -> IUU)
) -> operator(IUU, IUV, IUW, IUX).
postfix_custom(Precedence, Operator, Apply) ->
    {operator,
        fun(Config) ->
            {Precedence,
                fun(Lhs) ->
                    chomp:do(
                        Operator(Config),
                        fun(Op) -> chomp:return(Apply(Lhs, Op)) end
                    )
                end}
        end}.

-spec postfix(integer(), chomp:parser(any(), IUI, IUJ, IUK), fun((IUP) -> IUP)) -> operator(IUP, IUI, IUJ, IUK).
postfix(Precedence, Operator, Apply) ->
    postfix_custom(
        Precedence,
        fun(_) -> Operator end,
        fun(A, _) -> Apply(A) end
    ).

-spec operator_custom(
    fun((config(IVL, IVM, IVN, IVO)) -> {integer(),
        fun((IVL) -> chomp:parser(IVL, IVM, IVN, IVO))})
) -> operator(IVL, IVM, IVN, IVO).
operator_custom(Build) ->
    {operator, Build}.