-module(gladvent@internal@cmd@run).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([timeout_flag/0, allow_crash_flag/0, run_command/0, run_all_command/0]).
-export_type([run_err/0, solve_err/0, direction/0, gleam_err/0]).

-type run_err() :: {failed_to_read_input, binary()} |
    {failed_to_parse_input, binary()} |
    {failed_to_get_runner, snag:snag()} |
    {unregistered, integer()} |
    {other, binary()}.

-type solve_err() :: undef | {run_failed, binary()}.

-type direction() :: both.

-type gleam_err() :: {gleam_err,
        gleam@erlang@atom:atom_(),
        binary(),
        binary(),
        integer(),
        binary(),
        gleam@option:option(gleam@dynamic:dynamic_())}.

-spec run_err_to_snag(run_err()) -> snag:snag().
run_err_to_snag(Err) ->
    case Err of
        {unregistered, Day} ->
            snag:new(
                <<<<<<<<"day"/utf8, " "/utf8>>/binary,
                            (gleam@int:to_string(Day))/binary>>/binary,
                        " "/utf8>>/binary,
                    "unregistered"/utf8>>
            );

        {failed_to_read_input, Input_path} ->
            snag:new(<<"failed to read input file: "/utf8, Input_path/binary>>);

        {failed_to_parse_input, Err@1} ->
            snag:new(<<"failed to parse input: "/utf8, Err@1/binary>>);

        {failed_to_get_runner, S} ->
            snag:layer(S, <<"failed to get runner"/utf8>>);

        {other, S@1} ->
            snag:new(S@1)
    end.

-spec string_trim(binary(), direction(), binary()) -> binary().
string_trim(S, Dir, Sub) ->
    string:trim(S, Dir, unicode:characters_to_list(Sub)).

-spec crash_to_dyn(gleam@erlang:crash()) -> gleam@dynamic:dynamic_().
crash_to_dyn(Err) ->
    case Err of
        {errored, Dyn} ->
            Dyn;

        {exited, Dyn} ->
            Dyn;

        {thrown, Dyn} ->
            Dyn
    end.

-spec decode_gleam_err() -> fun((gleam@dynamic:dynamic_()) -> {ok, gleam_err()} |
    {error, list(gleam@dynamic:decode_error())}).
decode_gleam_err() ->
    gleam@dynamic:decode6(
        fun(Field@0, Field@1, Field@2, Field@3, Field@4, Field@5) -> {gleam_err, Field@0, Field@1, Field@2, Field@3, Field@4, Field@5} end,
        gleam@dynamic:field(
            erlang:binary_to_atom(<<"gleam_error"/utf8>>),
            fun gleam_erlang_ffi:atom_from_dynamic/1
        ),
        gleam@dynamic:field(
            erlang:binary_to_atom(<<"module"/utf8>>),
            fun gleam@dynamic:string/1
        ),
        gleam@dynamic:field(
            erlang:binary_to_atom(<<"function"/utf8>>),
            fun gleam@dynamic:string/1
        ),
        gleam@dynamic:field(
            erlang:binary_to_atom(<<"line"/utf8>>),
            fun gleam@dynamic:int/1
        ),
        gleam@dynamic:field(
            erlang:binary_to_atom(<<"message"/utf8>>),
            fun gleam@dynamic:string/1
        ),
        gleam@dynamic:any(
            [gleam@dynamic:field(
                    erlang:binary_to_atom(<<"value"/utf8>>),
                    gleam@dynamic:optional(fun gleam@dynamic:dynamic/1)
                ),
                fun(_) -> {ok, none} end]
        )
    ).

-spec gleam_err_to_string(gleam_err()) -> binary().
gleam_err_to_string(G) ->
    gleam@string:join(
        [<<"error:"/utf8>>,
            erlang:atom_to_binary(erlang:element(2, G)),
            <<"-"/utf8>>,
            erlang:element(6, G),
            <<"in module"/utf8>>,
            erlang:element(3, G),
            <<"in function"/utf8>>,
            erlang:element(4, G),
            <<"at line"/utf8>>,
            gleam@int:to_string(erlang:element(5, G)),
            begin
                _pipe = erlang:element(7, G),
                _pipe@1 = gleam@option:map(
                    _pipe,
                    fun(Val) ->
                        <<"with value "/utf8,
                            (gleam@string:inspect(Val))/binary>>
                    end
                ),
                gleam@option:unwrap(_pipe@1, <<""/utf8>>)
            end],
        <<" "/utf8>>
    ).

-spec crash_to_string(gleam@erlang:crash()) -> binary().
crash_to_string(Err) ->
    _pipe = crash_to_dyn(Err),
    _pipe@1 = (decode_gleam_err())(_pipe),
    _pipe@2 = gleam@result:map(_pipe@1, fun gleam_err_to_string/1),
    gleam@result:lazy_unwrap(
        _pipe@2,
        fun() ->
            <<"run failed for some reason: "/utf8,
                (gleam@string:inspect(Err))/binary>>
        end
    ).

-spec crash_to_solve_err(gleam@erlang:crash()) -> solve_err().
crash_to_solve_err(Err) ->
    _pipe = Err,
    _pipe@1 = crash_to_string(_pipe),
    {run_failed, _pipe@1}.

-spec do(integer(), integer(), gleam@package_interface:package(), boolean()) -> {ok,
        {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
            {ok, gleam@dynamic:dynamic_()} | {error, solve_err()}}} |
    {error, run_err()}.
do(Year, Day, Package, Allow_crash) ->
    gleam@result:'try'(
        begin
            _pipe = gladvent@internal@runners:get_day(Package, Year, Day),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {failed_to_get_runner, Field@0} end
            )
        end,
        fun(_use0) ->
            {Pt_1, Pt_2, Parse} = _use0,
            Input_path = filepath:join(
                gladvent@internal@cmd:input_dir(Year),
                <<(gleam@int:to_string(Day))/binary, ".txt"/utf8>>
            ),
            gleam@result:'try'(
                begin
                    _pipe@1 = Input_path,
                    _pipe@2 = simplifile:read(_pipe@1),
                    _pipe@3 = gleam@result:map(
                        _pipe@2,
                        fun(_capture) ->
                            string_trim(_capture, both, <<"\n"/utf8>>)
                        end
                    ),
                    gleam@result:replace_error(
                        _pipe@3,
                        {failed_to_read_input, Input_path}
                    )
                end,
                fun(Input) ->
                    Parse@1 = gleam@option:unwrap(
                        Parse,
                        fun gleam@dynamic:from/1
                    ),
                    case Allow_crash of
                        true ->
                            Input@1 = Parse@1(Input),
                            {ok, {{ok, Pt_1(Input@1)}, {ok, Pt_2(Input@1)}}};

                        false ->
                            gleam@result:'try'(
                                begin
                                    _pipe@4 = fun() -> Parse@1(Input) end,
                                    _pipe@5 = gleam_erlang_ffi:rescue(_pipe@4),
                                    _pipe@6 = gleam@result:map_error(
                                        _pipe@5,
                                        fun crash_to_string/1
                                    ),
                                    gleam@result:map_error(
                                        _pipe@6,
                                        fun(Field@0) -> {failed_to_parse_input, Field@0} end
                                    )
                                end,
                                fun(Input@2) ->
                                    Pt_1@1 = begin
                                        _pipe@7 = fun() -> Pt_1(Input@2) end,
                                        _pipe@8 = gleam_erlang_ffi:rescue(
                                            _pipe@7
                                        ),
                                        gleam@result:map_error(
                                            _pipe@8,
                                            fun crash_to_solve_err/1
                                        )
                                    end,
                                    Pt_2@1 = begin
                                        _pipe@9 = fun() -> Pt_2(Input@2) end,
                                        _pipe@10 = gleam_erlang_ffi:rescue(
                                            _pipe@9
                                        ),
                                        gleam@result:map_error(
                                            _pipe@10,
                                            fun crash_to_solve_err/1
                                        )
                                    end,
                                    {ok, {Pt_1@1, Pt_2@1}}
                                end
                            )
                    end
                end
            )
        end
    ).

-spec solve_err_to_string(solve_err()) -> binary().
solve_err_to_string(Solve_err) ->
    case Solve_err of
        undef ->
            <<"function undefined"/utf8>>;

        {run_failed, S} ->
            S
    end.

-spec solve_res_to_string({ok, gleam@dynamic:dynamic_()} | {error, solve_err()}) -> binary().
solve_res_to_string(Res) ->
    case Res of
        {ok, Res@1} ->
            gleam@string:inspect(Res@1);

        {error, Err} ->
            solve_err_to_string(Err)
    end.

-spec collect(
    integer(),
    {integer(),
        {ok,
                {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
                    {ok, gleam@dynamic:dynamic_()} | {error, solve_err()}}} |
            {error, run_err()}}
) -> binary().
collect(Year, X) ->
    Day = gleam@int:to_string(erlang:element(1, X)),
    case erlang:element(2, X) of
        {ok, {Res_1, Res_2}} ->
            <<<<<<<<<<<<<<<<<<"Ran "/utf8, (gleam@int:to_string(Year))/binary>>/binary,
                                            " day "/utf8>>/binary,
                                        Day/binary>>/binary,
                                    ":\n"/utf8>>/binary,
                                "  Part 1: "/utf8>>/binary,
                            (solve_res_to_string(Res_1))/binary>>/binary,
                        "\n"/utf8>>/binary,
                    "  Part 2: "/utf8>>/binary,
                (solve_res_to_string(Res_2))/binary>>;

        {error, Err} ->
            _pipe = Err,
            _pipe@1 = run_err_to_snag(_pipe),
            _pipe@2 = snag:layer(
                _pipe@1,
                <<<<<<"Failed to run "/utf8,
                            (gleam@int:to_string(Year))/binary>>/binary,
                        " day "/utf8>>/binary,
                    Day/binary>>
            ),
            snag:pretty_print(_pipe@2)
    end.

-spec collect_async(
    integer(),
    {integer(),
        {ok,
                {ok,
                        {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
                            {ok, gleam@dynamic:dynamic_()} |
                                {error, solve_err()}}} |
                    {error, run_err()}} |
            {error, binary()}}
) -> binary().
collect_async(Year, X) ->
    _pipe = X,
    _pipe@1 = gleam@pair:map_second(
        _pipe,
        fun(_capture) ->
            gleam@result:map_error(
                _capture,
                fun(Field@0) -> {other, Field@0} end
            )
        end
    ),
    _pipe@2 = gleam@pair:map_second(_pipe@1, fun gleam@result:flatten/1),
    collect(Year, _pipe@2).

-spec timeout_flag() -> glint:flag(integer()).
timeout_flag() ->
    glint:flag_constraint(
        begin
            _pipe = glint:int_flag(<<"timeout"/utf8>>),
            glint:flag_help(_pipe, <<"Run with specified timeout"/utf8>>)
        end,
        fun(I) -> case I > 0 of
                true ->
                    {ok, I};

                false ->
                    snag:error(<<"timeout value must greater than zero"/utf8>>)
            end end
    ).

-spec allow_crash_flag() -> glint:flag(boolean()).
allow_crash_flag() ->
    _pipe = glint:bool_flag(<<"allow-crash"/utf8>>),
    _pipe@1 = glint:flag_default(_pipe, false),
    glint:flag_help(
        _pipe@1,
        <<"Don't catch exceptions thrown by runners"/utf8>>
    ).

-spec run_command() -> glint:command({ok, list(binary())} | {error, snag:snag()}).
run_command() ->
    glint:command_help(
        <<"Run the specified days"/utf8>>,
        fun() ->
            glint:unnamed_args(
                {min_args, 1},
                fun() ->
                    glint:command(
                        fun(_, Args, Flags) ->
                            gleam@result:then(
                                gladvent@internal@parse:days(Args),
                                fun(Days) ->
                                    _assert_subject = glint:get_flag(
                                        Flags,
                                        gladvent@internal@cmd:year_flag()
                                    ),
                                    {ok, Year} = case _assert_subject of
                                        {ok, _} -> _assert_subject;
                                        _assert_fail ->
                                            erlang:error(
                                                    #{gleam_error => let_assert,
                                                        message => <<"Assertion pattern match failed"/utf8>>,
                                                        value => _assert_fail,
                                                        module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                        function => <<"run_command"/utf8>>,
                                                        line => 261}
                                                )
                                    end,
                                    _assert_subject@1 = glint:get_flag(
                                        Flags,
                                        allow_crash_flag()
                                    ),
                                    {ok, Allow_crash} = case _assert_subject@1 of
                                        {ok, _} -> _assert_subject@1;
                                        _assert_fail@1 ->
                                            erlang:error(
                                                    #{gleam_error => let_assert,
                                                        message => <<"Assertion pattern match failed"/utf8>>,
                                                        value => _assert_fail@1,
                                                        module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                        function => <<"run_command"/utf8>>,
                                                        line => 262}
                                                )
                                    end,
                                    Spinner = begin
                                        _pipe = spinner:new(
                                            <<<<<<"running days "/utf8,
                                                        (gleam@string:join(
                                                            Args,
                                                            <<", "/utf8>>
                                                        ))/binary>>/binary,
                                                    " in "/utf8>>/binary,
                                                (gleam@int:to_string(Year))/binary>>
                                        ),
                                        spinner:start(_pipe)
                                    end,
                                    gladvent@internal@util:defer(
                                        fun() -> spinner:stop(Spinner) end,
                                        fun() ->
                                            Timing = begin
                                                _pipe@1 = glint:get_flag(
                                                    Flags,
                                                    timeout_flag()
                                                ),
                                                _pipe@2 = gleam@result:map(
                                                    _pipe@1,
                                                    fun(Field@0) -> {ending, Field@0} end
                                                ),
                                                gleam@result:unwrap(
                                                    _pipe@2,
                                                    endless
                                                )
                                            end,
                                            gleam@result:map(
                                                begin
                                                    _pipe@3 = gladvent@internal@runners:pkg_interface(
                                                        
                                                    ),
                                                    snag:context(
                                                        _pipe@3,
                                                        <<"failed to generate package interface"/utf8>>
                                                    )
                                                end,
                                                fun(Package) -> _pipe@4 = Days,
                                                    gladvent@internal@cmd:exec(
                                                        _pipe@4,
                                                        Timing,
                                                        fun(_capture) ->
                                                            do(
                                                                Year,
                                                                _capture,
                                                                Package,
                                                                Allow_crash
                                                            )
                                                        end,
                                                        fun(_capture@1) ->
                                                            collect_async(
                                                                Year,
                                                                _capture@1
                                                            )
                                                        end
                                                    ) end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec run_all_command() -> glint:command({ok, list(binary())} |
    {error, snag:snag()}).
run_all_command() ->
    glint:command_help(
        <<"Run all registered days"/utf8>>,
        fun() ->
            glint:unnamed_args(
                {eq_args, 0},
                fun() ->
                    glint:command(
                        fun(_, _, Flags) ->
                            _assert_subject = glint:get_flag(
                                Flags,
                                gladvent@internal@cmd:year_flag()
                            ),
                            {ok, Year} = case _assert_subject of
                                {ok, _} -> _assert_subject;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 294})
                            end,
                            _assert_subject@1 = glint:get_flag(
                                Flags,
                                allow_crash_flag()
                            ),
                            {ok, Allow_crash} = case _assert_subject@1 of
                                {ok, _} -> _assert_subject@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail@1,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 295})
                            end,
                            Spinner = begin
                                _pipe = spinner:new(
                                    <<"running all days in "/utf8,
                                        (gleam@int:to_string(Year))/binary>>
                                ),
                                spinner:start(_pipe)
                            end,
                            gladvent@internal@util:defer(
                                fun() -> spinner:stop(Spinner) end,
                                fun() ->
                                    Timing = begin
                                        _pipe@1 = glint:get_flag(
                                            Flags,
                                            timeout_flag()
                                        ),
                                        _pipe@2 = gleam@result:map(
                                            _pipe@1,
                                            fun(Field@0) -> {ending, Field@0} end
                                        ),
                                        gleam@result:unwrap(_pipe@2, endless)
                                    end,
                                    gleam@result:map(
                                        begin
                                            _pipe@3 = gladvent@internal@runners:pkg_interface(
                                                
                                            ),
                                            snag:context(
                                                _pipe@3,
                                                <<"failed to generate package interface"/utf8>>
                                            )
                                        end,
                                        fun(Package) ->
                                            _pipe@4 = erlang:element(5, Package),
                                            _pipe@5 = gleam@dict:keys(_pipe@4),
                                            _pipe@8 = gleam@list:filter_map(
                                                _pipe@5,
                                                fun(K) ->
                                                    gleam@result:'try'(
                                                        gleam@string:split_once(
                                                            K,
                                                            <<<<"aoc_"/utf8,
                                                                    (gleam@int:to_string(
                                                                        Year
                                                                    ))/binary>>/binary,
                                                                "/day_"/utf8>>
                                                        ),
                                                        fun(Day) ->
                                                            _pipe@6 = erlang:element(
                                                                2,
                                                                Day
                                                            ),
                                                            _pipe@7 = gladvent@internal@parse:day(
                                                                _pipe@6
                                                            ),
                                                            gleam@result:replace_error(
                                                                _pipe@7,
                                                                nil
                                                            )
                                                        end
                                                    )
                                                end
                                            ),
                                            _pipe@9 = gleam@list:sort(
                                                _pipe@8,
                                                fun gleam@int:compare/2
                                            ),
                                            gladvent@internal@cmd:exec(
                                                _pipe@9,
                                                Timing,
                                                fun(_capture) ->
                                                    do(
                                                        Year,
                                                        _capture,
                                                        Package,
                                                        Allow_crash
                                                    )
                                                end,
                                                fun(_capture@1) ->
                                                    collect_async(
                                                        Year,
                                                        _capture@1
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).