-module(yum@yaml@parser@block_scalar).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/yum/yaml/parser/block_scalar.gleam").
-export([parser/0]).
-export_type([header/0, line/0]).

-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).

-type header() :: {header,
        yum@yaml@token:block_scalar_style(),
        yum@yaml@token:chomp(),
        integer(),
        yum@yaml@node:span()}.

-type line() :: {line, integer(), binary(), yum@yaml@node:span()}.

-file("src/yum/yaml/parser/block_scalar.gleam", 92).
?DOC(false).
-spec block_span(header(), list(line())) -> yum@yaml@node:span().
block_span(Header, Lines) ->
    case gleam@list:last(Lines) of
        {ok, Line} ->
            {span, Start, _} = erlang:element(5, Header),
            {span, _, End} = erlang:element(4, Line),
            {span, Start, End};

        {error, _} ->
            erlang:element(5, Header)
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 222).
?DOC(false).
-spec apply_chomp(binary(), list(binary()), integer(), yum@yaml@token:chomp()) -> binary().
apply_chomp(Content, Content_lines, Trailing_empty_lines, Chomp) ->
    case {Chomp, Content_lines} of
        {strip, _} ->
            Content;

        {clip, []} ->
            <<""/utf8>>;

        {clip, _} ->
            <<Content/binary, "\n"/utf8>>;

        {keep, []} ->
            gleam@string:repeat(<<"\n"/utf8>>, Trailing_empty_lines);

        {keep, _} ->
            <<<<Content/binary, "\n"/utf8>>/binary,
                (gleam@string:repeat(<<"\n"/utf8>>, Trailing_empty_lines))/binary>>
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 199).
?DOC(false).
-spec fold_lines_loop(list(binary()), list(binary()), integer()) -> list(binary()).
fold_lines_loop(Lines, Parts, Empty_lines) ->
    case Lines of
        [] ->
            Parts;

        [Line | Rest] ->
            case {gleam@string:is_empty(Line), Parts} of
                {true, _} ->
                    fold_lines_loop(Rest, Parts, Empty_lines + 1);

                {false, []} ->
                    fold_lines_loop(Rest, [Line], 0);

                {false, [_ | _]} ->
                    Separator = case Empty_lines of
                        0 ->
                            <<" "/utf8>>;

                        _ ->
                            gleam@string:repeat(<<"\n"/utf8>>, Empty_lines)
                    end,
                    fold_lines_loop(Rest, [Line, Separator | Parts], 0)
            end
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 193).
?DOC(false).
-spec fold_lines(list(binary())) -> binary().
fold_lines(Lines) ->
    _pipe = fold_lines_loop(Lines, [], 0),
    _pipe@1 = lists:reverse(_pipe),
    erlang:list_to_binary(_pipe@1).

-file("src/yum/yaml/parser/block_scalar.gleam", 186).
?DOC(false).
-spec empty_lines(integer(), list(binary())) -> list(binary()).
empty_lines(Count, Content) ->
    case Count of
        0 ->
            Content;

        _ ->
            empty_lines(Count - 1, [<<""/utf8>> | Content])
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 167).
?DOC(false).
-spec split_trailing_empty_loop(list(binary()), integer(), list(binary())) -> {integer(),
    list(binary())}.
split_trailing_empty_loop(Lines, Trailing, Content) ->
    case Lines of
        [] ->
            {Trailing, lists:reverse(Content)};

        [Line | Rest] ->
            case {gleam@string:is_empty(Line), Content} of
                {true, []} ->
                    split_trailing_empty_loop(Rest, Trailing + 1, Content);

                {_, _} ->
                    split_trailing_empty_loop(
                        Rest,
                        0,
                        [Line | empty_lines(Trailing, Content)]
                    )
            end
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 161).
?DOC(false).
-spec split_trailing_empty(list(binary())) -> {list(binary()), integer()}.
split_trailing_empty(Lines) ->
    {Trailing, Content} = split_trailing_empty_loop(Lines, 0, []),
    {Content, Trailing}.

-file("src/yum/yaml/parser/block_scalar.gleam", 152).
?DOC(false).
-spec normalize_line(line(), integer()) -> binary().
normalize_line(Line, Content_indent) ->
    {line, Indent, Content, _} = Line,
    case gleam@string:is_empty(Content) of
        true ->
            <<""/utf8>>;

        false ->
            <<(gleam@string:repeat(
                    <<" "/utf8>>,
                    gleam@int:max(0, Indent - Content_indent)
                ))/binary,
                Content/binary>>
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 145).
?DOC(false).
-spec min_indent_loop(list(integer()), integer()) -> integer().
min_indent_loop(Indents, Current) ->
    case Indents of
        [] ->
            Current;

        [Indent | Rest] ->
            min_indent_loop(Rest, gleam@int:min(Current, Indent))
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 138).
?DOC(false).
-spec min_indent(list(integer()), integer()) -> integer().
min_indent(Indents, Default) ->
    case Indents of
        [] ->
            Default;

        [First | Rest] ->
            min_indent_loop(Rest, First)
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 123).
?DOC(false).
-spec content_indent(list(line()), integer()) -> integer().
content_indent(Lines, Parent_indent) ->
    _pipe = Lines,
    _pipe@1 = gleam@list:filter(_pipe, fun(Line) -> case Line of
                {line, _, <<""/utf8>>, _} ->
                    false;

                {line, Indent, _, _} ->
                    Indent > Parent_indent
            end end),
    _pipe@2 = gleam@list:map(
        _pipe@1,
        fun(Line@1) ->
            {line, Indent@1, _, _} = Line@1,
            Indent@1
        end
    ),
    min_indent(_pipe@2, Parent_indent + 1).

-file("src/yum/yaml/parser/block_scalar.gleam", 116).
?DOC(false).
-spec normalize_lines(list(line()), integer()) -> list(binary()).
normalize_lines(Lines, Parent_indent) ->
    Content_indent = content_indent(Lines, Parent_indent),
    _pipe = Lines,
    gleam@list:map(_pipe, fun(Line) -> normalize_line(Line, Content_indent) end).

-file("src/yum/yaml/parser/block_scalar.gleam", 103).
?DOC(false).
-spec render(header(), list(line())) -> binary().
render(Header, Lines) ->
    {header, Style, Chomp, Parent_indent, _} = Header,
    Normalized = normalize_lines(Lines, Parent_indent),
    {Content_lines, Trailing_empty_lines} = split_trailing_empty(Normalized),
    Content = case Style of
        literal ->
            gleam@string:join(Content_lines, <<"\n"/utf8>>);

        folded ->
            fold_lines(Content_lines)
    end,
    apply_chomp(Content, Content_lines, Trailing_empty_lines, Chomp).

-file("src/yum/yaml/parser/block_scalar.gleam", 82).
?DOC(false).
-spec invalid_content_line(list(line()), integer()) -> boolean().
invalid_content_line(Lines, Parent_indent) ->
    _pipe = Lines,
    gleam@list:any(_pipe, fun(Line) -> case Line of
                {line, _, <<""/utf8>>, _} ->
                    false;

                {line, Indent, _, _} ->
                    Indent =< Parent_indent
            end end).

-file("src/yum/yaml/parser/block_scalar.gleam", 72).
?DOC(false).
-spec validate_lines(header(), list(line())) -> nibble:parser(nil, yum@yaml@token:token(), yum@yaml@lexer@context:context()).
validate_lines(Header, Lines) ->
    case invalid_content_line(Lines, erlang:element(4, Header)) of
        true ->
            nibble:fail(<<"Expected block scalar content to be indented"/utf8>>);

        false ->
            nibble:return(nil)
    end.

-file("src/yum/yaml/parser/block_scalar.gleam", 56).
?DOC(false).
-spec line_parser() -> nibble:parser(line(), yum@yaml@token:token(), yum@yaml@lexer@context:context()).
line_parser() ->
    nibble:do(
        nibble:take_map(
            <<"Expected a block scalar line"/utf8>>,
            fun(Tok) -> case Tok of
                    {block_scalar_line, Indent, Content} ->
                        {some, {Indent, Content}};

                    _ ->
                        none
                end end
        ),
        fun(Line) ->
            nibble:do(
                nibble:span(),
                fun(Token_span) ->
                    {Indent@1, Content@1} = Line,
                    _pipe = {line,
                        Indent@1,
                        Content@1,
                        yum@yaml@parser@span:from_lexer(Token_span)},
                    nibble:return(_pipe)
                end
            )
        end
    ).

-file("src/yum/yaml/parser/block_scalar.gleam", 39).
?DOC(false).
-spec header_parser() -> nibble:parser(header(), yum@yaml@token:token(), yum@yaml@lexer@context:context()).
header_parser() ->
    nibble:do(
        nibble:take_map(
            <<"Expected a block scalar header"/utf8>>,
            fun(Tok) -> case Tok of
                    {block_scalar_header, Style, Chomp, Parent_indent} ->
                        {some, {Style, Chomp, Parent_indent}};

                    _ ->
                        none
                end end
        ),
        fun(Header) ->
            nibble:do(
                nibble:span(),
                fun(Token_span) ->
                    {Style@1, Chomp@1, Parent_indent@1} = Header,
                    _pipe = {header,
                        Style@1,
                        Chomp@1,
                        Parent_indent@1,
                        yum@yaml@parser@span:from_lexer(Token_span)},
                    nibble:return(_pipe)
                end
            )
        end
    ).

-file("src/yum/yaml/parser/block_scalar.gleam", 24).
?DOC(false).
-spec parser() -> nibble:parser(yum@yaml@node:node_(), yum@yaml@token:token(), yum@yaml@lexer@context:context()).
parser() ->
    nibble:do(
        header_parser(),
        fun(Header) ->
            nibble:do(
                nibble:many(line_parser()),
                fun(Lines) ->
                    nibble:do(
                        validate_lines(Header, Lines),
                        fun(_) ->
                            Style = case erlang:element(2, Header) of
                                literal ->
                                    literal_block_scalar;

                                folded ->
                                    folded_block_scalar
                            end,
                            _pipe = render(Header, Lines),
                            _pipe@1 = {string, _pipe},
                            _pipe@2 = yum@yaml@node:new(
                                _pipe@1,
                                block_span(Header, Lines),
                                Style
                            ),
                            nibble:return(_pipe@2)
                        end
                    )
                end
            )
        end
    ).