-module(startest@test_failure).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_string/1, rescue/1]).
-export_type([test_failure/0, panic_info/0, panic_key/0]).

-type test_failure() :: {assertion_error,
        startest@assertion_error:rescued_assertion_error()} |
    {generic_error, exception:exception()}.

-type panic_info() :: {panic_info, binary(), binary(), integer(), binary()}.

-type panic_key() :: module | function | message | line.

-spec to_string(test_failure()) -> binary().
to_string(Failure) ->
    case Failure of
        {assertion_error, Assertion_error} ->
            erlang:element(2, Assertion_error);

        {generic_error, Exception} ->
            gleam@string:inspect(Exception)
    end.

-spec try_decode_panic_info(exception:exception()) -> {ok, panic_info()} |
    {error, nil}.
try_decode_panic_info(Exception) ->
    Err@1 = case Exception of
        {errored, Err} ->
            Err;

        {thrown, Err} ->
            Err;

        {exited, Err} ->
            Err
    end,
    case gleam@dynamic:classify(Err@1) of
        <<"Dict"/utf8>> ->
            gleam@result:'try'(
                begin
                    _pipe = Err@1,
                    _pipe@1 = (gleam@dynamic:dict(
                        fun gleam@dynamic:dynamic/1,
                        fun gleam@dynamic:dynamic/1
                    ))(_pipe),
                    gleam@result:nil_error(_pipe@1)
                end,
                fun(Dict) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = Dict,
                            _pipe@3 = gleam@dict:get(
                                _pipe@2,
                                gleam@dynamic:from(module)
                            ),
                            gleam@result:then(
                                _pipe@3,
                                fun(Value) -> _pipe@4 = Value,
                                    _pipe@5 = gleam@dynamic:string(_pipe@4),
                                    gleam@result:nil_error(_pipe@5) end
                            )
                        end,
                        fun(Module) ->
                            gleam@result:'try'(
                                begin
                                    _pipe@6 = Dict,
                                    _pipe@7 = gleam@dict:get(
                                        _pipe@6,
                                        gleam@dynamic:from(function)
                                    ),
                                    gleam@result:then(
                                        _pipe@7,
                                        fun(Value@1) -> _pipe@8 = Value@1,
                                            _pipe@9 = gleam@dynamic:string(
                                                _pipe@8
                                            ),
                                            gleam@result:nil_error(_pipe@9) end
                                    )
                                end,
                                fun(Function) ->
                                    gleam@result:'try'(
                                        begin
                                            _pipe@10 = Dict,
                                            _pipe@11 = gleam@dict:get(
                                                _pipe@10,
                                                gleam@dynamic:from(line)
                                            ),
                                            gleam@result:then(
                                                _pipe@11,
                                                fun(Value@2) ->
                                                    _pipe@12 = Value@2,
                                                    _pipe@13 = gleam@dynamic:int(
                                                        _pipe@12
                                                    ),
                                                    gleam@result:nil_error(
                                                        _pipe@13
                                                    )
                                                end
                                            )
                                        end,
                                        fun(Line) ->
                                            gleam@result:'try'(
                                                begin
                                                    _pipe@14 = Dict,
                                                    _pipe@15 = gleam@dict:get(
                                                        _pipe@14,
                                                        gleam@dynamic:from(
                                                            message
                                                        )
                                                    ),
                                                    gleam@result:then(
                                                        _pipe@15,
                                                        fun(Value@3) ->
                                                            _pipe@16 = Value@3,
                                                            _pipe@17 = gleam@dynamic:string(
                                                                _pipe@16
                                                            ),
                                                            gleam@result:nil_error(
                                                                _pipe@17
                                                            )
                                                        end
                                                    )
                                                end,
                                                fun(Message) ->
                                                    {ok,
                                                        {panic_info,
                                                            Module,
                                                            Function,
                                                            Line,
                                                            Message}}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"Object"/utf8>> ->
            gleam@result:'try'(
                begin
                    _pipe@18 = Err@1,
                    _pipe@19 = (gleam@dynamic:field(
                        <<"module"/utf8>>,
                        fun gleam@dynamic:string/1
                    ))(_pipe@18),
                    gleam@result:nil_error(_pipe@19)
                end,
                fun(Module@1) ->
                    gleam@result:'try'(
                        begin
                            _pipe@20 = Err@1,
                            _pipe@21 = (gleam@dynamic:field(
                                <<"fn"/utf8>>,
                                fun gleam@dynamic:string/1
                            ))(_pipe@20),
                            gleam@result:nil_error(_pipe@21)
                        end,
                        fun(Function@1) ->
                            gleam@result:'try'(
                                begin
                                    _pipe@22 = Err@1,
                                    _pipe@23 = (gleam@dynamic:field(
                                        <<"line"/utf8>>,
                                        fun gleam@dynamic:int/1
                                    ))(_pipe@22),
                                    gleam@result:nil_error(_pipe@23)
                                end,
                                fun(Line@1) ->
                                    gleam@result:'try'(
                                        begin
                                            _pipe@24 = Err@1,
                                            _pipe@25 = (gleam@dynamic:field(
                                                <<"message"/utf8>>,
                                                fun gleam@dynamic:string/1
                                            ))(_pipe@24),
                                            gleam@result:nil_error(_pipe@25)
                                        end,
                                        fun(Message@1) ->
                                            {ok,
                                                {panic_info,
                                                    Module@1,
                                                    Function@1,
                                                    Line@1,
                                                    Message@1}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, nil}
    end.

-spec rescue(fun(() -> nil)) -> {ok, nil} | {error, test_failure()}.
rescue(F) ->
    case exception_ffi:rescue(F) of
        {ok, nil} ->
            {ok, nil};

        {error, Exception} ->
            Panic_info = begin
                _pipe = Exception,
                try_decode_panic_info(_pipe)
            end,
            case Panic_info of
                {ok, Panic_info@1} ->
                    {error,
                        {assertion_error,
                            {rescued_assertion_error,
                                erlang:element(5, Panic_info@1)}}};

                {error, nil} ->
                    {error, {generic_error, Exception}}
            end
    end.