-module(examples@info_string).
-compile(no_auto_import).

-export([language_parser/0, info_string_parser/0, get_language/1, is_eval/1, parse/1]).
-export_type([flag/0, named/0, argument/0, eval_info_string/0]).

-type flag() :: {flag, binary()}.

-type named() :: {named, binary(), binary()}.

-type argument() :: {argument_flag, flag()} | {argument_named, named()}.

-type eval_info_string() :: {eval_info_string,
                             binary(),
                             list(flag()),
                             list(named())}.

-spec whitespace_surrounded() -> fun((fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                                     parser_gleam@parse_result:parse_success(binary(), GTI)} |
    {error, parser_gleam@parse_result:parse_error(binary())})) -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                                                                 parser_gleam@parse_result:parse_success(binary(), GTI)} |
    {error, parser_gleam@parse_result:parse_error(binary())})).
whitespace_surrounded() ->
    parser_gleam@parser:surrounded_by(parser_gleam@string:spaces()).

-spec double_dash() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                      parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
double_dash() ->
    parser_gleam@string:string(<<"--"/utf8>>).

-spec equals() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                 parser_gleam@parse_result:parse_success(binary(), binary())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
equals() ->
    parser_gleam@char:char(<<"="/utf8>>).

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

-spec flag() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                               parser_gleam@parse_result:parse_success(binary(), flag())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
flag() ->
    _pipe = double_dash(),
    _pipe@1 = parser_gleam@parser:chain(_pipe, fun(_) -> identifier() end),
    parser_gleam@parser:map(_pipe@1, fun(A) -> {flag, A} end).

-spec named() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                parser_gleam@parse_result:parse_success(binary(), named())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
named() ->
    _pipe = double_dash(),
    _pipe@1 = parser_gleam@parser:chain(
        _pipe,
        fun(_) -> parser_gleam@parser:sep_by1(equals(), identifier()) end
    ),
    parser_gleam@parser:chain(
        _pipe@1,
        fun(Nea) ->
            Lst = begin
                _pipe@2 = Nea,
                fp_gl@non_empty_list:to_list(_pipe@2)
            end,
            case begin
                _pipe@3 = Lst,
                gleam@list:length(_pipe@3)
            end of
                2 ->
                    [Name, Value] = Lst,
                    case gleam@string:length(Value) of
                        0 ->
                            parser_gleam@parser:fail();

                        _@1 ->
                            parser_gleam@parser:'of'({named, Name, Value})
                    end;

                _@2 ->
                    parser_gleam@parser:fail()
            end
        end
    ).

-spec argument() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                   parser_gleam@parse_result:parse_success(binary(), argument())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
argument() ->
    parser_gleam@parser:either(
        begin
            _pipe = named(),
            parser_gleam@parser:map(_pipe, fun(A) -> {argument_named, A} end)
        end,
        fun() ->
            _pipe@1 = flag(),
            parser_gleam@parser:map(_pipe@1, fun(A) -> {argument_flag, A} end)
        end
    ).

-spec language_parser() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                          parser_gleam@parse_result:parse_success(binary(), gleam@option:option(binary()))} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
language_parser() ->
    _pipe@1 = parser_gleam@parser:many_till(
        parser_gleam@parser:item(),
        parser_gleam@parser:look_ahead(
            parser_gleam@parser:either(
                parser_gleam@string:string(<<" "/utf8>>),
                fun() ->
                    _pipe = parser_gleam@parser:eof(),
                    parser_gleam@parser:map(_pipe, fun(_) -> <<""/utf8>> end)
                end
            )
        )
    ),
    _pipe@3 = parser_gleam@parser:map(
        _pipe@1,
        fun(Str) ->
            _pipe@2 = Str,
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end
    ),
    parser_gleam@parser:map(_pipe@3, fun(It) -> case gleam@string:length(It) of
                0 ->
                    none;

                _@1 ->
                    {some, It}
            end end).

-spec eval_parser() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                      parser_gleam@parse_result:parse_success(binary(), {binary(),
                                                                                                                         binary()})} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
eval_parser() ->
    _pipe = language_parser(),
    _pipe@1 = parser_gleam@parser:chain(_pipe, fun(Lang) -> case Lang of
                none ->
                    parser_gleam@parser:fail();

                {some, It} ->
                    parser_gleam@parser:'of'(It)
            end end),
    _pipe@2 = parser_gleam@parser:chain_first(
        _pipe@1,
        fun(_) -> parser_gleam@string:string(<<" "/utf8>>) end
    ),
    parser_gleam@parser:chain(
        _pipe@2,
        fun(Language) ->
            _pipe@3 = parser_gleam@string:string(<<"eval"/utf8>>),
            parser_gleam@parser:chain(
                _pipe@3,
                fun(Eval_str) ->
                    parser_gleam@parser:'of'({Language, Eval_str})
                end
            )
        end
    ).

-spec info_string_parser() -> fun((parser_gleam@stream:stream(binary())) -> {ok,
                                                                             parser_gleam@parse_result:parse_success(binary(), eval_info_string())} |
    {error, parser_gleam@parse_result:parse_error(binary())}).
info_string_parser() ->
    _pipe = eval_parser(),
    parser_gleam@parser:chain(
        _pipe,
        fun(Eval) ->
            _pipe@1 = argument(),
            _pipe@2 = (whitespace_surrounded())(_pipe@1),
            _pipe@3 = parser_gleam@parser:many(_pipe@2),
            parser_gleam@parser:map(
                _pipe@3,
                fun(Args) ->
                    {Lang, _@1} = Eval,
                    _pipe@4 = Args,
                    gleam@list:fold(
                        _pipe@4,
                        {eval_info_string, Lang, [], []},
                        fun(P, C) -> case C of
                                {argument_flag, F} ->
                                    {eval_info_string,
                                     erlang:element(2, P),
                                     gleam@list:append(
                                         [F],
                                         erlang:element(3, P)
                                     ),
                                     erlang:element(4, P)};

                                {argument_named, N} ->
                                    {eval_info_string,
                                     erlang:element(2, P),
                                     erlang:element(3, P),
                                     gleam@list:append(
                                         [N],
                                         erlang:element(4, P)
                                     )}
                            end end
                    )
                end
            )
        end
    ).

-spec get_language(binary()) -> gleam@option:option(binary()).
get_language(Info_string) ->
    case begin
        _pipe = language_parser(),
        (parser_gleam@string:run(Info_string))(_pipe)
    end of
        {error, _@1} ->
            none;

        {ok, It} ->
            erlang:element(2, It)
    end.

-spec is_eval(binary()) -> boolean().
is_eval(Info_string) ->
    case begin
        _pipe = eval_parser(),
        (parser_gleam@string:run(Info_string))(_pipe)
    end of
        {error, _@1} ->
            false;

        {ok, _@2} ->
            true
    end.

-spec parse(binary()) -> {ok,
                          parser_gleam@parse_result:parse_success(binary(), eval_info_string())} |
    {error, parser_gleam@parse_result:parse_error(binary())}.
parse(Info_string) ->
    _pipe = info_string_parser(),
    (parser_gleam@string:run(Info_string))(_pipe).