-module(parser_gleam@string).
-compile(no_auto_import).

-export([string/1, one_of/1, fold/1, maybe/1, many/1, many1/1, spaces/0, spaces1/0, not_spaces/0, not_spaces1/0, int/0, float/0, double_quoted_string/0, run/1]).

-spec char_at(integer(), binary()) -> gleam@option:option(binary()).
char_at(Index, S) ->
    R = begin
        _pipe = S,
        _pipe@1 = gleam@string:to_graphemes(_pipe),
        gleam@list:at(_pipe@1, Index)
    end,
    case R of
        {ok, V} ->
            {some, V};

        {error, _@1} ->
            none
    end.

-spec slice(integer(), binary()) -> binary().
slice(Index, S) ->
    _pipe = S,
    gleam@string:slice(_pipe, Index, gleam@string:length(S) - Index).

-spec string(binary()) -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                         parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
string(S) ->
    parser_gleam@parser:expected(
        parser_gleam@parser:chain_rec(S, fun(Acc) -> case char_at(0, Acc) of
                    none ->
                        parser_gleam@parser:'of'({ok, S});

                    {some, Ch} ->
                        _pipe = parser_gleam@char:char(Ch),
                        parser_gleam@parser:chain(
                            _pipe,
                            fun(_) ->
                                parser_gleam@parser:'of'({error, slice(1, Acc)})
                            end
                        )
                end end),
        gleam@string:inspect(S)
    ).

-spec one_of(list(binary())) -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                               parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
one_of(Lst) ->
    _pipe = Lst,
    gleam@list:fold(
        _pipe,
        parser_gleam@parser:fail(),
        fun(Prev, Str) ->
            _pipe@1 = Prev,
            parser_gleam@parser:alt(_pipe@1, fun() -> string(Str) end)
        end
    ).

-spec fold(
    list(fun((parser_gleam@stream:stream(FZF)) -> {ok,
                                                   parser_gleam@parse_result:parse_success(FZF, binary())} |
        {error, parser_gleam@parse_result:parse_error(FZF)}))
) -> fun((parser_gleam@stream:stream(FZF)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FZF, binary())} |
    {error, parser_gleam@parse_result:parse_error(FZF)}).
fold(Ass) ->
    _pipe = Ass,
    (fp2@monoid:concat_all(
        parser_gleam@parser:get_monoid(fp2@monoid:monoid_string())
    ))(_pipe).

-spec maybe(
    fun((parser_gleam@stream:stream(FZL)) -> {ok,
                                              parser_gleam@parse_result:parse_success(FZL, binary())} |
        {error, parser_gleam@parse_result:parse_error(FZL)})
) -> fun((parser_gleam@stream:stream(FZL)) -> {ok,
                                               parser_gleam@parse_result:parse_success(FZL, binary())} |
    {error, parser_gleam@parse_result:parse_error(FZL)}).
maybe(P) ->
    (parser_gleam@parser:maybe(fp2@monoid:monoid_string()))(P).

-spec many(
    fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                   parser_gleam@parse_result:parse_success(binary(), binary())} |
        {error, parser_gleam@parse_result:parse_error(binary())})
) -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                    parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
many(Parser) ->
    maybe(many1(Parser)).

-spec many1(
    fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                   parser_gleam@parse_result:parse_success(binary(), binary())} |
        {error, parser_gleam@parse_result:parse_error(binary())})
) -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                    parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
many1(Parser) ->
    _pipe = parser_gleam@parser:many1(Parser),
    parser_gleam@parser:map(
        _pipe,
        fun(Nea) ->
            _pipe@1 = Nea,
            _pipe@2 = fp2@non_empty_list:to_list(_pipe@1),
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end
    ).

-spec spaces() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                 parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
spaces() ->
    parser_gleam@char:many(parser_gleam@char:space()).

-spec spaces1() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                  parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
spaces1() ->
    parser_gleam@char:many1(parser_gleam@char:space()).

-spec not_spaces() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                     parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
not_spaces() ->
    parser_gleam@char:many(parser_gleam@char:not_space()).

-spec not_spaces1() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                      parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
not_spaces1() ->
    parser_gleam@char:many1(parser_gleam@char:not_space()).

-spec int() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                              parser_gleam@parse_result:parse_success(binary(), integer())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
int() ->
    Exp = begin
        _pipe = [maybe(parser_gleam@char:char(<<"-"/utf8>>)),
                 parser_gleam@char:many1(parser_gleam@char:digit())],
        _pipe@1 = fold(_pipe),
        parser_gleam@parser:chain(_pipe@1, fun(S) -> case gleam@int:parse(S) of
                    {ok, I} ->
                        parser_gleam@parser:succeed(I);

                    {error, _@1} ->
                        parser_gleam@parser:fail()
                end end)
    end,
    parser_gleam@parser:expected(Exp, <<"an integer"/utf8>>).

-spec float() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                parser_gleam@parse_result:parse_success(binary(), float())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
float() ->
    Exp = begin
        _pipe = [maybe(parser_gleam@char:char(<<"-"/utf8>>)),
                 parser_gleam@char:many1(parser_gleam@char:digit()),
                 maybe(
                     fold(
                         [parser_gleam@char:char(<<"."/utf8>>),
                          parser_gleam@char:many1(parser_gleam@char:digit())]
                     )
                 )],
        _pipe@1 = fold(_pipe),
        parser_gleam@parser:chain(
            _pipe@1,
            fun(S) -> case gleam@float:parse(S) of
                    {ok, It} ->
                        parser_gleam@parser:succeed(It);

                    {error, _@1} ->
                        case gleam@int:parse(S) of
                            {ok, I} ->
                                parser_gleam@parser:succeed(
                                    begin
                                        _pipe@2 = I,
                                        gleam@int:to_float(_pipe@2)
                                    end
                                );

                            {error, _@2} ->
                                parser_gleam@parser:fail()
                        end
                end end
        )
    end,
    parser_gleam@parser:expected(Exp, <<"a float"/utf8>>).

-spec double_quoted_string() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                               parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
double_quoted_string() ->
    _pipe = many(
        parser_gleam@parser:either(
            string(<<"\\\""/utf8>>),
            fun() -> parser_gleam@char:not_char(<<"\""/utf8>>) end
        )
    ),
    (parser_gleam@parser:surrounded_by(parser_gleam@char:char(<<"\""/utf8>>)))(
        _pipe
    ).

-spec run(binary()) -> fun((fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                           parser_gleam@parse_result:parse_success(binary(), GEL)} |
    {error, parser_gleam@parse_result:parse_error(binary())})) -> {ok,
                                                                   parser_gleam@parse_result:parse_success(binary(), GEL)} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
run(Str) ->
    fun(P) ->
        P(
            parser_gleam@stream:stream(
                begin
                    _pipe = Str,
                    gleam@string:to_graphemes(_pipe)
                end,
                none
            )
        )
    end.