-module(taffy@parser@helpers).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/taffy/parser/helpers.gleam").
-export([current/1, advance/1, backtrack/1, skip_whitespace/1, flow_whitespace_has_comment/1, skip_flow_whitespace/1, skip_newlines_and_comments/1, skip_newlines_and_comments_tracking/1, is_terminator/1, token_to_string/1, token_for_error/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).

-file("src/taffy/parser/helpers.gleam", 8).
?DOC(false).
-spec current(taffy@parser@types:parser()) -> gleam@option:option(taffy@lexer:token()).
current(Parser) ->
    case erlang:element(2, Parser) of
        [First | _] ->
            {some, First};

        [] ->
            none
    end.

-file("src/taffy/parser/helpers.gleam", 15).
?DOC(false).
-spec advance(taffy@parser@types:parser()) -> taffy@parser@types:parser().
advance(Parser) ->
    case erlang:element(2, Parser) of
        [First | Rest] ->
            {parser,
                Rest,
                [First | erlang:element(3, Parser)],
                erlang:element(4, Parser) + 1,
                erlang:element(5, Parser),
                erlang:element(6, Parser),
                erlang:element(7, Parser),
                erlang:element(8, Parser),
                erlang:element(9, Parser),
                erlang:element(10, Parser),
                erlang:element(11, Parser),
                erlang:element(12, Parser),
                erlang:element(13, Parser)};

        [] ->
            Parser
    end.

-file("src/taffy/parser/helpers.gleam", 30).
?DOC(false).
-spec backtrack(taffy@parser@types:parser()) -> taffy@parser@types:parser().
backtrack(Parser) ->
    case erlang:element(3, Parser) of
        [Last | Rest] ->
            {parser,
                [Last | erlang:element(2, Parser)],
                Rest,
                erlang:element(4, Parser) - 1,
                erlang:element(5, Parser),
                erlang:element(6, Parser),
                erlang:element(7, Parser),
                erlang:element(8, Parser),
                erlang:element(9, Parser),
                erlang:element(10, Parser),
                erlang:element(11, Parser),
                erlang:element(12, Parser),
                erlang:element(13, Parser)};

        [] ->
            Parser
    end.

-file("src/taffy/parser/helpers.gleam", 43).
?DOC(false).
-spec skip_whitespace(taffy@parser@types:parser()) -> taffy@parser@types:parser().
skip_whitespace(Parser) ->
    case current(Parser) of
        {some, newline} ->
            skip_whitespace(advance(Parser));

        {some, {indent, _}} ->
            skip_whitespace(advance(Parser));

        {some, {comment, _}} ->
            skip_whitespace(advance(Parser));

        _ ->
            Parser
    end.

-file("src/taffy/parser/helpers.gleam", 52).
?DOC(false).
-spec flow_whitespace_has_comment(taffy@parser@types:parser()) -> boolean().
flow_whitespace_has_comment(Parser) ->
    case current(Parser) of
        {some, {comment, _}} ->
            true;

        {some, newline} ->
            flow_whitespace_has_comment(advance(Parser));

        {some, {indent, _}} ->
            flow_whitespace_has_comment(advance(Parser));

        _ ->
            false
    end.

-file("src/taffy/parser/helpers.gleam", 61).
?DOC(false).
-spec skip_flow_whitespace(taffy@parser@types:parser()) -> {ok,
        taffy@parser@types:parser()} |
    {error, taffy@parser@types:parse_error()}.
skip_flow_whitespace(Parser) ->
    case current(Parser) of
        {some, newline} ->
            Parser@1 = {parser,
                erlang:element(2, Parser),
                erlang:element(3, Parser),
                erlang:element(4, Parser),
                erlang:element(5, Parser),
                erlang:element(6, Parser),
                erlang:element(7, Parser),
                erlang:element(8, Parser),
                true,
                erlang:element(10, Parser),
                erlang:element(11, Parser),
                erlang:element(12, Parser),
                erlang:element(13, Parser)},
            case erlang:element(8, Parser@1) > 0 of
                true ->
                    After = advance(Parser@1),
                    case current(After) of
                        {some, newline} ->
                            skip_flow_whitespace(After);

                        {some, {indent, _}} ->
                            skip_flow_whitespace(After);

                        {some, {comment, _}} ->
                            skip_flow_whitespace(After);

                        {some, eof} ->
                            {ok, After};

                        none ->
                            {ok, After};

                        {some, bracket_close} ->
                            {ok, After};

                        {some, brace_close} ->
                            {ok, After};

                        {some, comma} ->
                            {ok, After};

                        _ ->
                            {error,
                                {parse_error,
                                    <<"Flow content must be indented"/utf8>>,
                                    erlang:element(4, Parser@1)}}
                    end;

                false ->
                    skip_flow_whitespace(advance(Parser@1))
            end;

        {some, {indent, N}} ->
            Parser@2 = {parser,
                erlang:element(2, Parser),
                erlang:element(3, Parser),
                erlang:element(4, Parser),
                erlang:element(5, Parser),
                erlang:element(6, Parser),
                erlang:element(7, Parser),
                erlang:element(8, Parser),
                true,
                erlang:element(10, Parser),
                erlang:element(11, Parser),
                erlang:element(12, Parser),
                erlang:element(13, Parser)},
            case N >= erlang:element(8, Parser@2) of
                true ->
                    skip_flow_whitespace(advance(Parser@2));

                false ->
                    After@1 = advance(Parser@2),
                    case current(After@1) of
                        {some, bracket_close} ->
                            {ok, After@1};

                        {some, brace_close} ->
                            {ok, After@1};

                        {some, comma} ->
                            {ok, After@1};

                        _ ->
                            {error,
                                {parse_error,
                                    <<"Flow content must be indented"/utf8>>,
                                    erlang:element(4, Parser@2)}}
                    end
            end;

        {some, {comment, _}} ->
            skip_flow_whitespace(advance(Parser));

        _ ->
            {ok, Parser}
    end.

-file("src/taffy/parser/helpers.gleam", 110).
?DOC(false).
-spec skip_newlines_and_comments(taffy@parser@types:parser()) -> taffy@parser@types:parser().
skip_newlines_and_comments(Parser) ->
    case current(Parser) of
        {some, newline} ->
            skip_newlines_and_comments(advance(Parser));

        {some, {comment, _}} ->
            skip_newlines_and_comments(advance(Parser));

        {some, {indent, _}} ->
            After_indent = advance(Parser),
            case current(After_indent) of
                {some, {comment, _}} ->
                    skip_newlines_and_comments(advance(After_indent));

                {some, newline} ->
                    skip_newlines_and_comments(advance(After_indent));

                _ ->
                    Parser
            end;

        _ ->
            Parser
    end.

-file("src/taffy/parser/helpers.gleam", 131).
?DOC(false).
-spec skip_newlines_and_comments_tracking_loop(
    taffy@parser@types:parser(),
    boolean()
) -> {boolean(), taffy@parser@types:parser()}.
skip_newlines_and_comments_tracking_loop(Parser, Skipped_newline) ->
    case current(Parser) of
        {some, newline} ->
            skip_newlines_and_comments_tracking_loop(advance(Parser), true);

        {some, {comment, _}} ->
            skip_newlines_and_comments_tracking_loop(
                advance(Parser),
                Skipped_newline
            );

        {some, {indent, _}} ->
            After_indent = advance(Parser),
            case current(After_indent) of
                {some, {comment, _}} ->
                    skip_newlines_and_comments_tracking_loop(
                        advance(After_indent),
                        Skipped_newline
                    );

                {some, newline} ->
                    skip_newlines_and_comments_tracking_loop(
                        advance(After_indent),
                        true
                    );

                _ ->
                    {Skipped_newline, Parser}
            end;

        _ ->
            {Skipped_newline, Parser}
    end.

-file("src/taffy/parser/helpers.gleam", 127).
?DOC(false).
-spec skip_newlines_and_comments_tracking(taffy@parser@types:parser()) -> {boolean(),
    taffy@parser@types:parser()}.
skip_newlines_and_comments_tracking(Parser) ->
    skip_newlines_and_comments_tracking_loop(Parser, false).

-file("src/taffy/parser/helpers.gleam", 160).
?DOC(false).
-spec is_terminator(gleam@option:option(taffy@lexer:token())) -> boolean().
is_terminator(Token) ->
    case Token of
        {some, newline} ->
            true;

        {some, {indent, _}} ->
            true;

        {some, {comment, _}} ->
            true;

        {some, eof} ->
            true;

        none ->
            true;

        _ ->
            false
    end.

-file("src/taffy/parser/helpers.gleam", 172).
?DOC(false).
-spec token_to_string(taffy@lexer:token()) -> binary().
token_to_string(Token) ->
    case Token of
        doc_start ->
            <<"---"/utf8>>;

        doc_end ->
            <<"..."/utf8>>;

        colon ->
            <<":"/utf8>>;

        question ->
            <<"?"/utf8>>;

        dash ->
            <<"-"/utf8>>;

        bracket_open ->
            <<"["/utf8>>;

        bracket_close ->
            <<"]"/utf8>>;

        brace_open ->
            <<"{"/utf8>>;

        brace_close ->
            <<"}"/utf8>>;

        comma ->
            <<","/utf8>>;

        {anchor, N} ->
            <<"&"/utf8, N/binary>>;

        {alias, N@1} ->
            <<"*"/utf8, N@1/binary>>;

        {tag, T} ->
            T;

        {literal, _} ->
            <<"|"/utf8>>;

        {folded, _} ->
            <<">"/utf8>>;

        {plain, S} ->
            <<<<"plain("/utf8, S/binary>>/binary, ")"/utf8>>;

        {single_quoted, S@1} ->
            <<<<"'"/utf8, S@1/binary>>/binary, "'"/utf8>>;

        {double_quoted, S@2} ->
            <<<<"\""/utf8, S@2/binary>>/binary, "\""/utf8>>;

        {comment, C} ->
            <<"#"/utf8, C/binary>>;

        newline ->
            <<"\\n"/utf8>>;

        {indent, N@2} ->
            <<<<"indent("/utf8, (erlang:integer_to_binary(N@2))/binary>>/binary,
                ")"/utf8>>;

        {directive, D} ->
            <<"%"/utf8, D/binary>>;

        eof ->
            <<"EOF"/utf8>>
    end.

-file("src/taffy/parser/helpers.gleam", 202).
?DOC(false).
-spec token_for_error(taffy@lexer:token()) -> binary().
token_for_error(Token) ->
    case Token of
        {plain, S} ->
            S;

        newline ->
            <<"newline"/utf8>>;

        {indent, _} ->
            <<"indentation"/utf8>>;

        {comment, _} ->
            <<"comment"/utf8>>;

        eof ->
            <<"end of input"/utf8>>;

        Other ->
            token_to_string(Other)
    end.