-module(showtime@common@common_event_handler).
-compile(no_auto_import).

-export([handle_event/2]).
-export_type([test_state/0, handler_state/0]).

-type test_state() :: not_started | running | {finished, integer()}.

-type handler_state() :: {handler_state,
        test_state(),
        integer(),
        gleam@map:map_(binary(), gleam@map:map_(binary(), showtime@common@test_suite:test_run()))}.

-spec system_time() -> integer().
system_time() ->
    os:system_time(millisecond).

-spec handle_event(showtime@common@test_suite:test_event(), handler_state()) -> handler_state().
handle_event(Msg, State) ->
    Test_state = erlang:element(2, State),
    Num_done = erlang:element(3, State),
    Events = erlang:element(4, State),
    {Updated_test_state, Updated_num_done, Updated_events} = case Msg of
        start_test_run ->
            {running, Num_done, Events};

        {start_test_suite, Module} ->
            New_events = begin
                _pipe = Events,
                gleam@map:insert(
                    _pipe,
                    erlang:element(2, Module),
                    gleam@map:new()
                )
            end,
            {Test_state, Num_done, New_events};

        {start_test, Module@1, Test} ->
            Current_time = system_time(),
            New_events@1 = begin
                _pipe@1 = Events,
                gleam@map:update(
                    _pipe@1,
                    erlang:element(2, Module@1),
                    fun(Module_event) -> case Module_event of
                            {some, Module_event@1} ->
                                _pipe@2 = Module_event@1,
                                gleam@map:insert(
                                    _pipe@2,
                                    erlang:element(2, Test),
                                    {ongoing_test_run, Test, Current_time}
                                );

                            none ->
                                gleam@map:new()
                        end end
                )
            end,
            {Test_state, Num_done, New_events@1};

        {end_test, Module@2, Test@1, Result} ->
            Current_time@1 = system_time(),
            New_events@2 = gleam@map:update(
                Events,
                erlang:element(2, Module@2),
                fun(Maybe_module_event) ->
                    Module_event@2 = gleam@option:unwrap(
                        Maybe_module_event,
                        gleam@map:new()
                    ),
                    Maybe_test_run = begin
                        _pipe@3 = Module_event@2,
                        gleam@map:get(_pipe@3, erlang:element(2, Test@1))
                    end,
                    case Maybe_test_run of
                        {ok, {ongoing_test_run, Test_function, Started_at}} ->
                            _pipe@4 = Module_event@2,
                            gleam@map:insert(
                                _pipe@4,
                                erlang:element(2, Test@1),
                                {completed_test_run,
                                    Test_function,
                                    Current_time@1
                                    - Started_at,
                                    Result}
                            );

                        {error, _} ->
                            Module_event@2
                    end
                end
            ),
            {Test_state, Num_done, New_events@2};

        {end_test_suite, _} ->
            {Test_state, Num_done + 1, Events};

        {end_test_run, Num_modules} ->
            {{finished, Num_modules}, Num_done, Events};

        _ ->
            {running, Num_done, Events}
    end,
    {handler_state, Updated_test_state, Updated_num_done, Updated_events}.