chomp

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

-export([run/2, return/1, succeed/1, throw/1, fail/1, lazy/1, backtrackable/1, do/2, then/2, map/2, replace/2, or_error/2, replace_error/2, get_pos/0, is_at_end/0, token/1, 'end'/0, one_of/1, 'or'/2, optional/1, loop/2, until_end/1, sequence/2, many/1, many1/1, take_if/1, any/0, take_map/1, until/2, in/2, do_in/3, inspect/2]).
-export_type([parser/4, step/4, state/2, committed/0, error/2, loop/2]).

-opaque parser(GNE, GNF, GNG, GNH) :: {parser,
        fun((state(GNG, GNH)) -> step(GNE, GNF, GNG, GNH))}.

-type step(GNI, GNJ, GNK, GNL) :: {cont, committed(), GNI, state(GNK, GNL)} |
    {fail,
        committed(),
        error(GNJ, GNK),
        chomp@span:span(),
        list({chomp@span:span(), GNL})}.

-type state(GNM, GNN) :: {state,
        gleam@dict:dict(integer(), chomp@lexer:token(GNM)),
        integer(),
        chomp@span:span(),
        list({chomp@span:span(), GNN})}.

-type committed() :: {committed, boolean()}.

-type error(GNO, GNP) :: {custom, GNO} |
    end_of_input |
    {expected, GNP, GNP} |
    {unexpected, GNP} |
    {bad_parser, binary()}.

-type loop(GNQ, GNR) :: {continue, GNR} | {break, GNQ}.

-spec runwrap(state(GOH, GOI), parser(GOL, GOM, GOH, GOI)) -> step(GOL, GOM, GOH, GOI).
runwrap(State, Parser) ->
    {parser, Parse} = Parser,
    Parse(State).

-spec run(list(chomp@lexer:token(GNS)), parser(GNV, GNW, GNS, GNX)) -> {ok, GNV} |
    {error,
        {error(GNW, GNS), chomp@span:span(), list({chomp@span:span(), GNX})}}.
run(Src, Parser) ->
    Src@1 = gleam@list:index_fold(
        Src,
        gleam@dict:new(),
        fun(Dict, Tok, Idx) -> gleam@dict:insert(Dict, Idx, Tok) end
    ),
    Init = {state, Src@1, 0, {span, 1, 1, 1, 1}, []},
    case runwrap(Init, Parser) of
        {cont, _, A, _} ->
            {ok, A};

        {fail, _, Problem, Pos, Ctx} ->
            {error, {Problem, Pos, Ctx}}
    end.

-spec next(state(GOV, GOW)) -> {gleam@option:option(GOV), state(GOV, GOW)}.
next(State) ->
    case gleam@dict:get(erlang:element(2, State), erlang:element(3, State)) of
        {error, _} ->
            {none, State};

        {ok, {token, Span, _, Tok}} ->
            {{some, Tok},
                erlang:setelement(
                    4,
                    erlang:setelement(3, State, erlang:element(3, State) + 1),
                    Span
                )}
    end.

-spec return(GPC) -> parser(GPC, any(), any(), any()).
return(Value) ->
    {parser, fun(State) -> {cont, {committed, false}, Value, State} end}.

-spec succeed(GPK) -> parser(GPK, any(), any(), any()).
succeed(Value) ->
    return(Value).

-spec throw(GPS) -> parser(any(), GPS, any(), any()).
throw(Error) ->
    {parser,
        fun(State) ->
            Error@1 = {custom, Error},
            {fail,
                {committed, false},
                Error@1,
                erlang:element(4, State),
                erlang:element(5, State)}
        end}.

-spec fail(GQA) -> parser(any(), GQA, any(), any()).
fail(Error) ->
    throw(Error).

-spec lazy(fun(() -> parser(GQI, GQJ, GQK, GQL))) -> parser(GQI, GQJ, GQK, GQL).
lazy(Parser) ->
    {parser, fun(State) -> runwrap(State, Parser()) end}.

-spec backtrackable(parser(GQU, GQV, GQW, GQX)) -> parser(GQU, GQV, GQW, GQX).
backtrackable(Parser) ->
    {parser, fun(State) -> case runwrap(State, Parser) of
                {cont, _, A, State@1} ->
                    {cont, {committed, false}, A, State@1};

                {fail, _, Problem, Pos, Ctx} ->
                    {fail, {committed, false}, Problem, Pos, Ctx}
            end end}.

-spec should_commit(committed(), committed()) -> committed().
should_commit(A, B) ->
    {committed, A@1} = A,
    {committed, B@1} = B,
    {committed, A@1 orelse B@1}.

-spec do(parser(GRG, GRH, GRI, GRJ), fun((GRG) -> parser(GRO, GRH, GRI, GRJ))) -> parser(GRO, GRH, GRI, GRJ).
do(Parser, F) ->
    {parser, fun(State) -> case runwrap(State, Parser) of
                {cont, To_a, A, State@1} ->
                    case runwrap(State@1, F(A)) of
                        {cont, To_b, B, State@2} ->
                            {cont, should_commit(To_a, To_b), B, State@2};

                        {fail, To_b@1, Problem, Pos, Ctx} ->
                            {fail,
                                should_commit(To_a, To_b@1),
                                Problem,
                                Pos,
                                Ctx}
                    end;

                {fail, Committed, Problem@1, Pos@1, Ctx@1} ->
                    {fail, Committed, Problem@1, Pos@1, Ctx@1}
            end end}.

-spec then(parser(GSO, GSP, GSQ, GSR), fun((GSO) -> parser(GSW, GSP, GSQ, GSR))) -> parser(GSW, GSP, GSQ, GSR).
then(Parser, F) ->
    do(Parser, F).

-spec map(parser(GTF, GTG, GTH, GTI), fun((GTF) -> GTN)) -> parser(GTN, GTG, GTH, GTI).
map(Parser, F) ->
    do(Parser, fun(A) -> return(F(A)) end).

-spec replace(parser(any(), GTT, GTU, GTV), GUA) -> parser(GUA, GTT, GTU, GTV).
replace(Parser, B) ->
    map(Parser, fun(_) -> B end).

-spec or_error(parser(GUF, GUG, GUH, GUI), GUG) -> parser(GUF, GUG, GUH, GUI).
or_error(Parser, Error) ->
    {parser, fun(State) -> case runwrap(State, Parser) of
                {fail, Committed, end_of_input, Pos, Ctx} ->
                    {fail, Committed, end_of_input, Pos, Ctx};

                {fail, {committed, false}, _, Pos@1, Ctx@1} ->
                    {fail, {committed, false}, {custom, Error}, Pos@1, Ctx@1};

                Result ->
                    Result
            end end}.

-spec replace_error(parser(GUR, GUS, GUT, GUU), GUS) -> parser(GUR, GUS, GUT, GUU).
replace_error(Parser, Error) ->
    {parser, fun(State) -> case runwrap(State, Parser) of
                {fail, Committed, _, Pos, Ctx} ->
                    {fail, Committed, {custom, Error}, Pos, Ctx};

                Result ->
                    Result
            end end}.

-spec get_pos() -> parser(chomp@span:span(), any(), any(), any()).
get_pos() ->
    {parser,
        fun(State) ->
            {cont, {committed, false}, erlang:element(4, State), State}
        end}.

-spec is_at_end() -> parser(boolean(), any(), any(), any()).
is_at_end() ->
    {parser, fun(State) -> case next(State) of
                {{some, _}, _} ->
                    {cont, {committed, false}, false, State};

                {none, _} ->
                    {cont, {committed, false}, true, State}
            end end}.

-spec token(GVY) -> parser(chomp@span:span(), any(), GVY, any()).
token(Tok) ->
    {parser, fun(State) -> case next(State) of
                {{some, T}, State@1} when Tok =:= T ->
                    {cont,
                        {committed, true},
                        erlang:element(4, State@1),
                        State@1};

                {{some, T@1}, State@2} ->
                    {fail,
                        {committed, false},
                        {expected, Tok, T@1},
                        erlang:element(4, State@2),
                        erlang:element(5, State@2)};

                {none, State@3} ->
                    {fail,
                        {committed, false},
                        end_of_input,
                        erlang:element(4, State@3),
                        erlang:element(5, State@3)}
            end end}.

-spec 'end'() -> parser(nil, any(), any(), any()).
'end'() ->
    {parser, fun(State) -> case next(State) of
                {{some, Tok}, State@1} ->
                    {fail,
                        {committed, false},
                        {unexpected, Tok},
                        erlang:element(4, State@1),
                        erlang:element(5, State@1)};

                {none, _} ->
                    {cont, {committed, false}, nil, State}
            end end}.

-spec one_of(list(parser(GWM, GWN, GWO, GWP))) -> parser(GWM, GWN, GWO, GWP).
one_of(Parsers) ->
    {parser, fun(State) -> case Parsers of
                [] ->
                    {fail,
                        {committed, false},
                        {bad_parser,
                            <<"one_of requires at least one parser"/utf8>>},
                        erlang:element(4, State),
                        erlang:element(5, State)};

                [Parser] ->
                    runwrap(State, Parser);

                [Parser@1 | Rest] ->
                    case runwrap(State, Parser@1) of
                        {cont, _, _, _} = Result ->
                            Result;

                        {fail, {committed, true}, _, _, _} = Result@1 ->
                            Result@1;

                        {fail, _, _, _, _} ->
                            runwrap(State, one_of(Rest))
                    end
            end end}.

-spec 'or'(parser(GWZ, GXA, GXB, GXC), GWZ) -> parser(GWZ, GXA, GXB, GXC).
'or'(Parser, Default) ->
    one_of([Parser, return(Default)]).

-spec optional(parser(GXL, GXM, GXN, GXO)) -> parser(gleam@option:option(GXL), GXM, GXN, GXO).
optional(Parser) ->
    one_of([map(Parser, fun(Field@0) -> {some, Field@0} end), return(none)]).

-spec loop_help(
    fun((HUT) -> parser(loop(HVF, HUT), HUY, HUZ, HVA)),
    committed(),
    HUT,
    state(HUZ, HVA)
) -> step(HVF, HUY, HUZ, HVA).
loop_help(F, Commit, Loop_state, State) ->
    case runwrap(State, F(Loop_state)) of
        {cont, Can_backtrack, {continue, Next_loop_state}, Next_state} ->
            loop_help(
                F,
                should_commit(Commit, Can_backtrack),
                Next_loop_state,
                Next_state
            );

        {cont, Can_backtrack@1, {break, Result}, Next_state@1} ->
            {cont, should_commit(Commit, Can_backtrack@1), Result, Next_state@1};

        {fail, Can_backtrack@2, Problem, Pos, Ctx} ->
            {fail, should_commit(Commit, Can_backtrack@2), Problem, Pos, Ctx}
    end.

-spec loop(HBI, fun((HBI) -> parser(loop(HBJ, HBI), HBM, HBN, HBO))) -> parser(HBJ, HBM, HBN, HBO).
loop(Init, Step) ->
    {parser, fun(State) -> loop_help(Step, {committed, false}, Init, State) end}.

-spec until_end(parser(GZQ, GZR, GZS, GZT)) -> parser(list(GZQ), GZR, GZS, GZT).
until_end(Parser) ->
    loop([], fun(Xs) -> do(is_at_end(), fun(Is_at_end) -> case Is_at_end of
                        true ->
                            return({break, gleam@list:reverse(Xs)});

                        false ->
                            do(
                                Parser,
                                fun(X) -> return({continue, [X | Xs]}) end
                            )
                    end end) end).

-spec more(HAQ, parser(HAQ, HAR, HAS, HAT), parser(any(), HAR, HAS, HAT)) -> parser(list(HAQ), HAR, HAS, HAT).
more(X, Parser, Separator) ->
    loop(
        [X],
        fun(Xs) ->
            Break = fun() -> return({break, gleam@list:reverse(Xs)}) end,
            Continue = (do(
                Separator,
                fun(_) ->
                    do(Parser, fun(X@1) -> return({continue, [X@1 | Xs]}) end)
                end
            )),
            one_of([Continue, lazy(Break)])
        end
    ).

-spec sequence(parser(GXY, GXZ, GYA, GYB), parser(any(), GXZ, GYA, GYB)) -> parser(list(GXY), GXZ, GYA, GYB).
sequence(Parser, Sep) ->
    one_of(
        [begin
                _pipe = Parser,
                then(_pipe, fun(_capture) -> more(_capture, Parser, Sep) end)
            end,
            return([])]
    ).

-spec many(parser(GYQ, GYR, GYS, GYT)) -> parser(list(GYQ), GYR, GYS, GYT).
many(Parser) ->
    sequence(Parser, return(nil)).

-spec many1(parser(GZD, GZE, GZF, GZG)) -> parser(list(GZD), GZE, GZF, GZG).
many1(Parser) ->
    do(Parser, fun(X) -> do(many(Parser), fun(Xs) -> return([X | Xs]) end) end).

-spec take_if(fun((HCC) -> boolean())) -> parser(HCC, any(), HCC, any()).
take_if(Predicate) ->
    {parser,
        fun(State) ->
            {Tok, State@1} = next(State),
            case {Tok, gleam@option:map(Tok, Predicate)} of
                {{some, Tok@1}, {some, true}} ->
                    {cont, {committed, true}, Tok@1, State@1};

                {{some, Tok@2}, {some, false}} ->
                    {fail,
                        {committed, false},
                        {unexpected, Tok@2},
                        erlang:element(4, State@1),
                        erlang:element(5, State@1)};

                {_, _} ->
                    {fail,
                        {committed, false},
                        end_of_input,
                        erlang:element(4, State@1),
                        erlang:element(5, State@1)}
            end
        end}.

-spec any() -> parser(GVR, any(), GVR, any()).
any() ->
    take_if(fun(_) -> true end).

-spec take_map(fun((HCJ) -> gleam@option:option(HCK))) -> parser(HCK, any(), HCJ, any()).
take_map(F) ->
    {parser,
        fun(State) ->
            {Tok, State@1} = next(State),
            case {Tok, gleam@option:then(Tok, F)} of
                {none, _} ->
                    {fail,
                        {committed, false},
                        end_of_input,
                        erlang:element(4, State@1),
                        erlang:element(5, State@1)};

                {{some, Tok@1}, none} ->
                    {fail,
                        {committed, false},
                        {unexpected, Tok@1},
                        erlang:element(4, State@1),
                        erlang:element(5, State@1)};

                {_, {some, A}} ->
                    {cont, {committed, true}, A, State@1}
            end
        end}.

-spec until(parser(HAD, HAE, HAF, HAG), HAF) -> parser(list(HAD), HAE, HAF, HAG).
until(Parser, Tok) ->
    loop(
        [],
        fun(Xs) ->
            Break = take_map(fun(T) -> case T =:= Tok of
                        true ->
                            {some, {break, gleam@list:reverse(Xs)}};

                        false ->
                            none
                    end end),
            Continue = (do(Parser, fun(X) -> return({continue, [X | Xs]}) end)),
            one_of([Break, Continue])
        end
    ).

-spec push_context(state(HDE, HDF), HDF) -> state(HDE, HDF).
push_context(State, Context) ->
    erlang:setelement(
        5,
        State,
        [{erlang:element(4, State), Context} | erlang:element(5, State)]
    ).

-spec pop_context(state(HDK, HDL)) -> state(HDK, HDL).
pop_context(State) ->
    case erlang:element(5, State) of
        [] ->
            State;

        [_ | Context] ->
            erlang:setelement(5, State, Context)
    end.

-spec in(parser(HCS, HCT, HCU, HCV), HCV) -> parser(HCS, HCT, HCU, HCV).
in(Parser, Context) ->
    {parser, fun(State) -> case runwrap(push_context(State, Context), Parser) of
                {cont, Committed, A, State@1} ->
                    {cont, Committed, A, pop_context(State@1)};

                {fail, Committed@1, Problem, Pos, Ctx} ->
                    {fail, Committed@1, Problem, Pos, Ctx}
            end end}.

-spec do_in(
    GRX,
    parser(GRY, GRZ, GSA, GRX),
    fun((GRY) -> parser(GSF, GRZ, GSA, GRX))
) -> parser(GSF, GRZ, GSA, GRX).
do_in(Context, Parser, F) ->
    _pipe = do(Parser, F),
    in(_pipe, Context).

-spec inspect(parser(HDQ, HDR, HDS, HDT), binary()) -> parser(HDQ, HDR, HDS, HDT).
inspect(Parser, Message) ->
    {parser,
        fun(State) ->
            gleam@io:println(<<Message/binary, ": "/utf8>>),
            _pipe = runwrap(State, Parser),
            gleam@io:debug(_pipe)
        end}.