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

-file("src/glap/parser.gleam", 20).
-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", 48).
-spec parse_aux(
    list(binary()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument()),
    list(glap@arguments:argument())
) -> {ok, list(glap@cliargs:c_l_i_arg())} | {error, glap@error:parsing_error()}.
parse_aux(Args, Commands, Flags, Unnamed_arguments) ->
    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 => 55,
                                value => _assert_fail,
                                start => 1349,
                                'end' => 1403,
                                pattern_start => 1360,
                                pattern_end => 1396})
            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 => 60,
                                value => _assert_fail@1,
                                start => 1483,
                                'end' => 1540,
                                pattern_start => 1494,
                                pattern_end => 1530})
            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 => 66,
                                    value => _assert_fail@2,
                                    start => 1634,
                                    'end' => 1687,
                                    pattern_start => 1645,
                                    pattern_end => 1677})
                end,
                Name@1
            end
        ),
        gleam@string:join(_pipe, <<" | "/utf8>>)
    end,
    gleam@bool:guard(
        (Args =:= []) andalso (Required_commands /= []),
        {error,
            {missing_command,
                glap@utils:strformat(
                    <<"missing required command: {}"/utf8>>,
                    [Required_commands_str]
                )}},
        fun() ->
            gleam@bool:guard(
                (Args =:= []) andalso (Unnamed_arguments /= []),
                {error,
                    {missing_unnamed_argument,
                        <<"missing unnamed arguments"/utf8>>}},
                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@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 => 75,
                                                value => _assert_fail@3,
                                                start => 2094,
                                                'end' => 2133,
                                                pattern_start => 2105,
                                                pattern_end => 2126})
                            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@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 => 91,
                                                                value => _assert_fail@4,
                                                                start => 2799,
                                                                'end' => 2848,
                                                                pattern_start => 2810,
                                                                pattern_end => 2840}
                                                        )
                                            end,
                                            parse_aux(
                                                Args,
                                                Commands,
                                                [H2_flag@1 |
                                                    glap@utils:push_back(
                                                        Rest_flag@2,
                                                        H_flag@1
                                                    )],
                                                Unnamed_arguments
                                            )
                                        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@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 => 105,
                                                                                value => _assert_fail@5,
                                                                                start => 3362,
                                                                                'end' => 3407,
                                                                                pattern_start => 3373,
                                                                                pattern_end => 3395}
                                                                        )
                                                            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
                                            ),
                                            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@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 => 120,
                                                                        value => _assert_fail@6,
                                                                        start => 3732,
                                                                        'end' => 3774,
                                                                        pattern_start => 3743,
                                                                        pattern_end => 3758}
                                                                )
                                                    end,
                                                    {ok,
                                                        [Flag_cliarg |
                                                            Rest_result@1]}
                                                end
                                            )
                                        end
                                    );

                                {_,
                                    _,
                                    [{unnamed_argument, Name@2, _} |
                                        Rest_unnamed_argument]} ->
                                    Unnamed_argument_cliarg = {unnamed_argument,
                                        Name@2,
                                        H_args@1},
                                    Rest_result_r@1 = parse_aux(
                                        Rest_args@1,
                                        Commands,
                                        Flags,
                                        Rest_unnamed_argument
                                    ),
                                    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@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 => 132,
                                                                value => _assert_fail@7,
                                                                start => 4214,
                                                                'end' => 4256,
                                                                pattern_start => 4225,
                                                                pattern_end => 4240}
                                                        )
                                            end,
                                            {ok,
                                                [Unnamed_argument_cliarg |
                                                    Rest_result@3]}
                                        end
                                    );

                                {[_ | _], _, _} when Required_flags =/= [] ->
                                    erlang:error(#{gleam_error => panic,
                                            message => <<"missing required flags"/utf8>>,
                                            file => <<?FILEPATH/utf8>>,
                                            module => <<"glap/parser"/utf8>>,
                                            function => <<"parse_aux"/utf8>>,
                                            line => 138});

                                {[_ | _], _, _} when Unnamed_arguments =/= [] ->
                                    erlang:error(#{gleam_error => panic,
                                            message => <<"missing unnamed arguments"/utf8>>,
                                            file => <<?FILEPATH/utf8>>,
                                            module => <<"glap/parser"/utf8>>,
                                            function => <<"parse_aux"/utf8>>,
                                            line => 139});

                                {[{command, Name@3, _, _, Subs} | Rest_command],
                                    _,
                                    _} ->
                                    gleam@bool:lazy_guard(
                                        H_args@1 /= Name@3,
                                        fun() ->
                                            parse_aux(
                                                Args,
                                                Rest_command,
                                                Flags,
                                                Unnamed_arguments
                                            )
                                        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
                                            ),
                                            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@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 => 153,
                                                                        value => _assert_fail@8,
                                                                        start => 5230,
                                                                        'end' => 5272,
                                                                        pattern_start => 5241,
                                                                        pattern_end => 5256}
                                                                )
                                                    end,
                                                    Command_cliarg = {command,
                                                        Name@3,
                                                        true,
                                                        Rest_result@5},
                                                    {ok, [Command_cliarg]}
                                                end
                                            )
                                        end
                                    );

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

-file("src/glap/parser.gleam", 39).
-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
    ),
    parse_aux(Args, Subcommands, Subflags, Subunnamedarguments).

-file("src/glap/parser.gleam", 163).
-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())).