signal

-module(signal@testing).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([persistance_layer_complies_with_signal/1]).
-export_type([persistance_test_event/0]).

-type persistance_test_event() :: {simple_event, binary()} |
    {complex_event, binary(), list(integer())}.

-spec persistance_layer_stores_events(
    gleam@erlang@process:subject(signal:store_message(persistance_test_event()))
) -> {ok, nil} | {error, binary()}.
persistance_layer_stores_events(Persistance_layer) ->
    gleam@list:map(
        [{event,
                1,
                <<"1"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"2"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"3"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                2,
                <<"1"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"2"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"3"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}}],
        fun(Event) ->
            gleam@erlang@process:send(Persistance_layer, {store_event, Event})
        end
    ),
    gleam@result:'try'(
        gleam@erlang@process:call(
            Persistance_layer,
            fun(_capture) -> {get_stored_events, _capture, <<"1"/utf8>>} end,
            100
        ),
        fun(Agg1) ->
            gleam@result:'try'(
                gleam@erlang@process:call(
                    Persistance_layer,
                    fun(_capture@1) ->
                        {get_stored_events, _capture@1, <<"2"/utf8>>}
                    end,
                    100
                ),
                fun(Agg2) ->
                    gleam@result:'try'(
                        gleam@erlang@process:call(
                            Persistance_layer,
                            fun(_capture@2) ->
                                {get_stored_events, _capture@2, <<"3"/utf8>>}
                            end,
                            100
                        ),
                        fun(Agg3) ->
                            Retrieved_event_count = erlang:length(
                                gleam@list:flatten([Agg1, Agg2, Agg3])
                            ),
                            Test_event_count = erlang:length(
                                [{event,
                                        1,
                                        <<"1"/utf8>>,
                                        <<"SimpleEvent"/utf8>>,
                                        {simple_event, <<"simple"/utf8>>}},
                                    {event,
                                        1,
                                        <<"2"/utf8>>,
                                        <<"SimpleEvent"/utf8>>,
                                        {simple_event, <<"simple"/utf8>>}},
                                    {event,
                                        1,
                                        <<"3"/utf8>>,
                                        <<"SimpleEvent"/utf8>>,
                                        {simple_event, <<"simple"/utf8>>}},
                                    {event,
                                        2,
                                        <<"1"/utf8>>,
                                        <<"ComplexEvent"/utf8>>,
                                        {complex_event,
                                            <<"simple"/utf8>>,
                                            [1, 2, 3]}},
                                    {event,
                                        2,
                                        <<"2"/utf8>>,
                                        <<"ComplexEvent"/utf8>>,
                                        {complex_event,
                                            <<"simple"/utf8>>,
                                            [1, 2, 3]}},
                                    {event,
                                        2,
                                        <<"3"/utf8>>,
                                        <<"ComplexEvent"/utf8>>,
                                        {complex_event,
                                            <<"simple"/utf8>>,
                                            [1, 2, 3]}}]
                            ),
                            case Retrieved_event_count =:= Test_event_count of
                                true ->
                                    {ok, nil};

                                _ ->
                                    {error,
                                        <<<<<<"Stored "/utf8,
                                                    (gleam@int:to_string(
                                                        Test_event_count
                                                    ))/binary>>/binary,
                                                " events, but retrieved "/utf8>>/binary,
                                            (gleam@int:to_string(
                                                Retrieved_event_count
                                            ))/binary>>}
                            end
                        end
                    )
                end
            )
        end
    ).

-spec persistance_layer_retrieves_events_in_order(
    gleam@erlang@process:subject(signal:store_message(persistance_test_event()))
) -> {ok, nil} | {error, binary()}.
persistance_layer_retrieves_events_in_order(Persistance_layer) ->
    gleam@list:map(
        lists:reverse(
            [{event,
                    1,
                    <<"1"/utf8>>,
                    <<"SimpleEvent"/utf8>>,
                    {simple_event, <<"simple"/utf8>>}},
                {event,
                    1,
                    <<"2"/utf8>>,
                    <<"SimpleEvent"/utf8>>,
                    {simple_event, <<"simple"/utf8>>}},
                {event,
                    1,
                    <<"3"/utf8>>,
                    <<"SimpleEvent"/utf8>>,
                    {simple_event, <<"simple"/utf8>>}},
                {event,
                    2,
                    <<"1"/utf8>>,
                    <<"ComplexEvent"/utf8>>,
                    {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
                {event,
                    2,
                    <<"2"/utf8>>,
                    <<"ComplexEvent"/utf8>>,
                    {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
                {event,
                    2,
                    <<"3"/utf8>>,
                    <<"ComplexEvent"/utf8>>,
                    {complex_event, <<"simple"/utf8>>, [1, 2, 3]}}]
        ),
        fun(Event) ->
            gleam@erlang@process:send(Persistance_layer, {store_event, Event})
        end
    ),
    gleam@result:'try'(
        gleam@erlang@process:call(
            Persistance_layer,
            fun(_capture) -> {get_stored_events, _capture, <<"1"/utf8>>} end,
            100
        ),
        fun(Agg1) -> case Agg1 of
                [First | _] when erlang:element(2, First) =:= 1 ->
                    {ok, nil};

                [First@1 | _] ->
                    {error,
                        <<"Events should be sorted in ascending order according to aggrerate version, but the first event has version "/utf8,
                            (gleam@int:to_string(erlang:element(2, First@1)))/binary>>};

                _ ->
                    {error,
                        <<"No events retrieved, event though events were stored"/utf8>>}
            end end
    ).

-spec persistance_layer_retrieves_only_events_for_aggregate(
    gleam@erlang@process:subject(signal:store_message(persistance_test_event()))
) -> {ok, nil} | {error, binary()}.
persistance_layer_retrieves_only_events_for_aggregate(Persistance_layer) ->
    gleam@list:map(
        [{event,
                1,
                <<"1"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"2"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"3"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                2,
                <<"1"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"2"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"3"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}}],
        fun(Event) ->
            gleam@erlang@process:send(Persistance_layer, {store_event, Event})
        end
    ),
    gleam@result:'try'(
        gleam@erlang@process:call(
            Persistance_layer,
            fun(_capture) -> {get_stored_events, _capture, <<"1"/utf8>>} end,
            100
        ),
        fun(Agg1) ->
            case gleam@list:all(
                Agg1,
                fun(Event@1) -> erlang:element(3, Event@1) =:= <<"1"/utf8>> end
            ) of
                true ->
                    {ok, nil};

                _ ->
                    {error, <<"Retrieved events for other aggregates!"/utf8>>}
            end
        end
    ).

-spec persistance_layer_will_correctly_report_on_used_ids(
    gleam@erlang@process:subject(signal:store_message(persistance_test_event()))
) -> {ok, nil} | {error, binary()}.
persistance_layer_will_correctly_report_on_used_ids(Persistance_layer) ->
    gleam@list:map(
        [{event,
                1,
                <<"1"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"2"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                1,
                <<"3"/utf8>>,
                <<"SimpleEvent"/utf8>>,
                {simple_event, <<"simple"/utf8>>}},
            {event,
                2,
                <<"1"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"2"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}},
            {event,
                2,
                <<"3"/utf8>>,
                <<"ComplexEvent"/utf8>>,
                {complex_event, <<"simple"/utf8>>, [1, 2, 3]}}],
        fun(Event) ->
            gleam@erlang@process:send(Persistance_layer, {store_event, Event})
        end
    ),
    gleam@result:'try'(
        gleam@erlang@process:call(
            Persistance_layer,
            fun(_capture) -> {is_identity_available, _capture, <<"1"/utf8>>} end,
            100
        ),
        fun(Used_ids) -> case Used_ids of
                false ->
                    {ok, nil};

                _ ->
                    {error,
                        <<"Aggregate id 1 should be reported as taken, but it was reported as available!"/utf8>>}
            end end
    ).

-spec persistance_layer_complies_with_signal(
    gleam@erlang@process:subject(signal:store_message(persistance_test_event()))
) -> list({ok, nil} | {error, binary()}).
persistance_layer_complies_with_signal(Persistance_layer) ->
    [persistance_layer_stores_events(Persistance_layer),
        persistance_layer_retrieves_events_in_order(Persistance_layer),
        persistance_layer_retrieves_only_events_for_aggregate(Persistance_layer),
        persistance_layer_will_correctly_report_on_used_ids(Persistance_layer)].