-module(glap@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glap/parser.gleam").
-export([parser_print/1, parse/2, parse_argv/1]).
-export_type([parser/0]).

-type parser() :: {parser,
        binary(),
        list(glap@arguments:argument()),
        glap@parser_settings:parser_settings()}.

-file("src/glap/parser.gleam", 21).
-spec parser_print(parser()) -> nil.
parser_print(Parser) ->
    {parser, Description, Args, _} = Parser,
    gleam_stdlib:println(<<"Parser { "/utf8>>),
    gleam_stdlib:print(<<"\tdescription: "/utf8>>),
    gleam_stdlib:print(Description),
    gleam_stdlib:println(<<", "/utf8>>),
    gleam_stdlib:println(<<"\tcommands:"/utf8>>),
    gleam_stdlib:print(<<"\t\t"/utf8>>),
    _pipe = Args,
    _pipe@1 = gleam@list:map(_pipe, fun glap@arguments:argument_to_string/1),
    _pipe@2 = gleam@string:join(_pipe@1, <<"\n\t\t"/utf8>>),
    gleam_stdlib:println(_pipe@2),
    gleam_stdlib:println(<<" }"/utf8>>).

-file("src/glap/parser.gleam", 40).
-spec run_on_parse_error(glap@parser_settings:parser_settings()) -> nil.
run_on_parse_error(Settings) ->
    case erlang:element(3, Settings) of
        {some, F} ->
            F();

        none ->
            nil
    end.

-file("src/glap/parser.gleam", 63).
-spec parse_aux(
    list(binary()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument()),
    glap@parser_settings:parser_settings()
) -> {ok, list(glap@cliargs:c_l_i_arg())} | {error, glap@error:parsing_error()}.
parse_aux(Args, Commands, Flags, Unnamed_arguments, Parser_settings) ->
    Required_flags = gleam@list:filter(
        Flags,
        fun(Flag) ->
            Required@1 = case Flag of
                {flag, _, _, _, Required, _} -> Required;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"glap/parser"/utf8>>,
                                function => <<"parse_aux"/utf8>>,
                                line => 71,
                                value => _assert_fail,
                                start => 1712,
                                'end' => 1766,
                                pattern_start => 1723,
                                pattern_end => 1759})
            end,
            Required@1
        end
    ),
    Required_commands = gleam@list:filter(
        Commands,
        fun(Command) ->
            Required@3 = case Command of
                {command, _, _, Required@2, _} -> Required@2;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"glap/parser"/utf8>>,
                                function => <<"parse_aux"/utf8>>,
                                line => 76,
                                value => _assert_fail@1,
                                start => 1846,
                                'end' => 1903,
                                pattern_start => 1857,
                                pattern_end => 1893})
            end,
            Required@3
        end
    ),
    Required_commands_str = begin
        _pipe = gleam@list:map(
            Required_commands,
            fun(Command@1) ->
                Name@1 = case Command@1 of
                    {command, Name, _, _, _} -> Name;
                    _assert_fail@2 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"glap/parser"/utf8>>,
                                    function => <<"parse_aux"/utf8>>,
                                    line => 82,
                                    value => _assert_fail@2,
                                    start => 1997,
                                    'end' => 2050,
                                    pattern_start => 2008,
                                    pattern_end => 2040})
                end,
                Name@1
            end
        ),
        gleam@string:join(_pipe, <<" | "/utf8>>)
    end,
    gleam@bool:guard(
        ((Args =:= []) andalso (Required_commands /= [])) andalso erlang:element(
            2,
            Parser_settings
        ),
        {error,
            {missing_command,
                glap@utils:strformat(
                    <<"missing required command: {}"/utf8>>,
                    [Required_commands_str]
                )}},
        fun() ->
            gleam@bool:guard(
                ((Args =:= []) andalso (Unnamed_arguments /= [])) andalso erlang:element(
                    2,
                    Parser_settings
                ),
                begin
                    _pipe@2 = glap@utils:strformat(
                        <<"missing required flags: {}"/utf8>>,
                        [begin
                                _pipe@1 = gleam@list:map(
                                    Unnamed_arguments,
                                    fun(Cliarg) ->
                                        Name@3 = case Cliarg of
                                            {unnamed_argument, Name@2, _} -> Name@2;
                                            _assert_fail@3 ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                            file => <<?FILEPATH/utf8>>,
                                                            module => <<"glap/parser"/utf8>>,
                                                            function => <<"parse_aux"/utf8>>,
                                                            line => 95,
                                                            value => _assert_fail@3,
                                                            start => 2506,
                                                            'end' => 2560,
                                                            pattern_start => 2517,
                                                            pattern_end => 2551}
                                                    )
                                        end,
                                        Name@3
                                    end
                                ),
                                gleam@string:join(_pipe@1, <<", "/utf8>>)
                            end]
                    ),
                    _pipe@3 = {missing_required_flag, _pipe@2},
                    {error, _pipe@3}
                end,
                fun() ->
                    gleam@bool:guard(
                        Args =:= [],
                        {ok, []},
                        fun() ->
                            {H_args@1, Rest_args@1} = case Args of
                                [H_args | Rest_args] -> {H_args, Rest_args};
                                _assert_fail@4 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"glap/parser"/utf8>>,
                                                function => <<"parse_aux"/utf8>>,
                                                line => 107,
                                                value => _assert_fail@4,
                                                start => 2707,
                                                'end' => 2746,
                                                pattern_start => 2718,
                                                pattern_end => 2739})
                            end,
                            Should_be_flag = gleam_stdlib:string_starts_with(
                                H_args@1,
                                <<"-"/utf8>>
                            ),
                            case {Commands, Flags, Unnamed_arguments} of
                                {_,
                                    [{flag, Short, Long, _, _, Holds_value} |
                                        Rest_flag],
                                    _} when Should_be_flag ->
                                    gleam@bool:lazy_guard(
                                        not gleam_stdlib:string_starts_with(
                                            H_args@1,
                                            Short
                                        )
                                        andalso not gleam_stdlib:string_starts_with(
                                            H_args@1,
                                            Long
                                        ),
                                        fun() ->
                                            {
                                            H_flag@1,
                                                H2_flag@1,
                                                Rest_flag@2} = case Flags of
                                                [H_flag, H2_flag | Rest_flag@1] -> {
                                                H_flag,
                                                    H2_flag,
                                                    Rest_flag@1};
                                                _assert_fail@5 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"glap/parser"/utf8>>,
                                                                function => <<"parse_aux"/utf8>>,
                                                                line => 122,
                                                                value => _assert_fail@5,
                                                                start => 3327,
                                                                'end' => 3376,
                                                                pattern_start => 3338,
                                                                pattern_end => 3368}
                                                        )
                                            end,
                                            parse_aux(
                                                Args,
                                                Commands,
                                                [H2_flag@1 |
                                                    glap@utils:push_back(
                                                        Rest_flag@2,
                                                        H_flag@1
                                                    )],
                                                Unnamed_arguments,
                                                Parser_settings
                                            )
                                        end,
                                        fun() ->
                                            {Content, Rest_args2} = case Holds_value of
                                                true ->
                                                    case gleam@string:split_once(
                                                        H_args@1,
                                                        <<"="/utf8>>
                                                    ) of
                                                        {ok, {_, Value}} ->
                                                            {{some,
                                                                    gleam@string:trim(
                                                                        Value
                                                                    )},
                                                                Rest_args@1};

                                                        {error, nil} ->
                                                            {
                                                            Flag_content@1,
                                                                Rest@1} = case Rest_args@1 of
                                                                [Flag_content |
                                                                    Rest] -> {
                                                                Flag_content,
                                                                    Rest};
                                                                _assert_fail@6 ->
                                                                    erlang:error(
                                                                            #{gleam_error => let_assert,
                                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                                file => <<?FILEPATH/utf8>>,
                                                                                module => <<"glap/parser"/utf8>>,
                                                                                function => <<"parse_aux"/utf8>>,
                                                                                line => 136,
                                                                                value => _assert_fail@6,
                                                                                start => 3907,
                                                                                'end' => 3952,
                                                                                pattern_start => 3918,
                                                                                pattern_end => 3940}
                                                                        )
                                                            end,
                                                            {{some,
                                                                    Flag_content@1},
                                                                Rest@1}
                                                    end;

                                                false ->
                                                    {none, Rest_args@1}
                                            end,
                                            Flag_cliarg = {flag,
                                                Short,
                                                Long,
                                                Content},
                                            Rest_result_r = parse_aux(
                                                Rest_args2,
                                                Commands,
                                                Rest_flag,
                                                Unnamed_arguments,
                                                Parser_settings
                                            ),
                                            gleam@bool:guard(
                                                gleam@result:is_error(
                                                    Rest_result_r
                                                ),
                                                Rest_result_r,
                                                fun() ->
                                                    Rest_result@1 = case Rest_result_r of
                                                        {ok, Rest_result} -> Rest_result;
                                                        _assert_fail@7 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"glap/parser"/utf8>>,
                                                                        function => <<"parse_aux"/utf8>>,
                                                                        line => 151,
                                                                        value => _assert_fail@7,
                                                                        start => 4294,
                                                                        'end' => 4336,
                                                                        pattern_start => 4305,
                                                                        pattern_end => 4320}
                                                                )
                                                    end,
                                                    {ok,
                                                        [Flag_cliarg |
                                                            Rest_result@1]}
                                                end
                                            )
                                        end
                                    );

                                {_,
                                    _,
                                    [{unnamed_argument, Name@4, _} |
                                        Rest_unnamed_argument]} ->
                                    Unnamed_argument_cliarg = {unnamed_argument,
                                        Name@4,
                                        H_args@1},
                                    Rest_result_r@1 = parse_aux(
                                        Rest_args@1,
                                        Commands,
                                        Flags,
                                        Rest_unnamed_argument,
                                        Parser_settings
                                    ),
                                    gleam@bool:guard(
                                        gleam@result:is_error(Rest_result_r@1),
                                        Rest_result_r@1,
                                        fun() ->
                                            Rest_result@3 = case Rest_result_r@1 of
                                                {ok, Rest_result@2} -> Rest_result@2;
                                                _assert_fail@8 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"glap/parser"/utf8>>,
                                                                function => <<"parse_aux"/utf8>>,
                                                                line => 163,
                                                                value => _assert_fail@8,
                                                                start => 4793,
                                                                'end' => 4835,
                                                                pattern_start => 4804,
                                                                pattern_end => 4819}
                                                        )
                                            end,
                                            {ok,
                                                [Unnamed_argument_cliarg |
                                                    Rest_result@3]}
                                        end
                                    );

                                {[_ | _], _, _} when (Required_flags =/= []) andalso erlang:element(
                                    2,
                                    Parser_settings
                                ) ->
                                    _pipe@5 = glap@utils:strformat(
                                        <<"missing required flags: {}"/utf8>>,
                                        [begin
                                                _pipe@4 = gleam@list:map(
                                                    Required_flags,
                                                    fun(Cliarg@1) ->
                                                        {Short@2, Long@2} = case Cliarg@1 of
                                                            {flag,
                                                                Short@1,
                                                                Long@1,
                                                                _,
                                                                _,
                                                                _} -> {
                                                            Short@1,
                                                                Long@1};
                                                            _assert_fail@9 ->
                                                                erlang:error(
                                                                        #{gleam_error => let_assert,
                                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                            file => <<?FILEPATH/utf8>>,
                                                                            module => <<"glap/parser"/utf8>>,
                                                                            function => <<"parse_aux"/utf8>>,
                                                                            line => 172,
                                                                            value => _assert_fail@9,
                                                                            start => 5159,
                                                                            'end' => 5215,
                                                                            pattern_start => 5170,
                                                                            pattern_end => 5206}
                                                                    )
                                                        end,
                                                        <<<<<<<<"["/utf8,
                                                                        Short@2/binary>>/binary,
                                                                    "|"/utf8>>/binary,
                                                                Long@2/binary>>/binary,
                                                            "]"/utf8>>
                                                    end
                                                ),
                                                gleam@string:join(
                                                    _pipe@4,
                                                    <<", "/utf8>>
                                                )
                                            end]
                                    ),
                                    _pipe@6 = {missing_required_flag, _pipe@5},
                                    {error, _pipe@6};

                                {[_ | _], _, _} when (Unnamed_arguments =/= []) andalso erlang:element(
                                    2,
                                    Parser_settings
                                ) ->
                                    _pipe@8 = glap@utils:strformat(
                                        <<"missing required flags: {}"/utf8>>,
                                        [begin
                                                _pipe@7 = gleam@list:map(
                                                    Unnamed_arguments,
                                                    fun(Cliarg@2) ->
                                                        Name@6 = case Cliarg@2 of
                                                            {unnamed_argument,
                                                                Name@5,
                                                                _} -> Name@5;
                                                            _assert_fail@10 ->
                                                                erlang:error(
                                                                        #{gleam_error => let_assert,
                                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                            file => <<?FILEPATH/utf8>>,
                                                                            module => <<"glap/parser"/utf8>>,
                                                                            function => <<"parse_aux"/utf8>>,
                                                                            line => 185,
                                                                            value => _assert_fail@10,
                                                                            start => 5582,
                                                                            'end' => 5636,
                                                                            pattern_start => 5593,
                                                                            pattern_end => 5627}
                                                                    )
                                                        end,
                                                        Name@6
                                                    end
                                                ),
                                                gleam@string:join(
                                                    _pipe@7,
                                                    <<", "/utf8>>
                                                )
                                            end]
                                    ),
                                    _pipe@9 = {missing_required_flag, _pipe@8},
                                    {error, _pipe@9};

                                {[{command, Name@7, _, _, Subs} | Rest_command],
                                    _,
                                    _} ->
                                    gleam@bool:lazy_guard(
                                        H_args@1 /= Name@7,
                                        fun() ->
                                            parse_aux(
                                                Args,
                                                Rest_command,
                                                Flags,
                                                Unnamed_arguments,
                                                Parser_settings
                                            )
                                        end,
                                        fun() ->
                                            Subcommands = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_command/1
                                            ),
                                            Subflags = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_flag/1
                                            ),
                                            Subunnamedarguments = gleam@list:filter(
                                                Subs,
                                                fun glap@arguments:is_unnamed_argument/1
                                            ),
                                            Result_rest_r = parse_aux(
                                                Rest_args@1,
                                                Subcommands,
                                                Subflags,
                                                Subunnamedarguments,
                                                Parser_settings
                                            ),
                                            gleam@bool:guard(
                                                gleam@result:is_error(
                                                    Result_rest_r
                                                ),
                                                Result_rest_r,
                                                fun() ->
                                                    Rest_result@5 = case Result_rest_r of
                                                        {ok, Rest_result@4} -> Rest_result@4;
                                                        _assert_fail@11 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"glap/parser"/utf8>>,
                                                                        function => <<"parse_aux"/utf8>>,
                                                                        line => 206,
                                                                        value => _assert_fail@11,
                                                                        start => 6403,
                                                                        'end' => 6445,
                                                                        pattern_start => 6414,
                                                                        pattern_end => 6429}
                                                                )
                                                    end,
                                                    Command_cliarg = {command,
                                                        Name@7,
                                                        true,
                                                        Rest_result@5},
                                                    {ok, [Command_cliarg]}
                                                end
                                            )
                                        end
                                    );

                                {_, _, _} ->
                                    _pipe@10 = glap@utils:strformat(
                                        <<"argument '{}' unknown"/utf8>>,
                                        [H_args@1]
                                    ),
                                    _pipe@11 = {unknown_argument, _pipe@10},
                                    {error, _pipe@11}
                            end
                        end
                    )
                end
            )
        end
    ).

-file("src/glap/parser.gleam", 48).
-spec parse(parser(), list(binary())) -> {ok, list(glap@cliargs:c_l_i_arg())} |
    {error, glap@error:parsing_error()}.
parse(Parser, Args) ->
    Subcommands = gleam@list:filter(
        erlang:element(3, Parser),
        fun glap@arguments:is_command/1
    ),
    Subflags = gleam@list:filter(
        erlang:element(3, Parser),
        fun glap@arguments:is_flag/1
    ),
    Subunnamedarguments = gleam@list:filter(
        erlang:element(3, Parser),
        fun glap@arguments:is_unnamed_argument/1
    ),
    case parse_aux(
        Args,
        Subcommands,
        Subflags,
        Subunnamedarguments,
        erlang:element(4, Parser)
    ) of
        {ok, X} ->
            {ok, X};

        {error, E} ->
            run_on_parse_error(erlang:element(4, Parser)),
            {error, E}
    end.

-file("src/glap/parser.gleam", 219).
-spec parse_argv(parser()) -> {ok, list(glap@cliargs:c_l_i_arg())} |
    {error, glap@error:parsing_error()}.
parse_argv(Parser) ->
    parse(Parser, erlang:element(4, argv:load())).