#include <cassert>
#include <type_traits>

#include "freertos/event_group.hpp"

enum class Ready : EventBits_t
{
    uart = 1U,
    gpio = 2U,
    app = 4U
};

namespace
{
unsigned deletes;
TickType_t last_timeout;
} // namespace

extern "C" EventGroupHandle_t xEventGroupCreateStatic(
    StaticEventGroup_t * storage )
{
    *storage = MockEventGroup {};
    return storage;
}
extern "C" EventBits_t xEventGroupSetBits( EventGroupHandle_t group,
                                            EventBits_t bits )
{
    group->bits |= bits;
    return group->bits;
}
extern "C" EventBits_t xEventGroupClearBits( EventGroupHandle_t group,
                                              EventBits_t bits )
{
    const EventBits_t before = group->bits;
    group->bits &= ~bits;
    return before;
}
extern "C" EventBits_t xEventGroupGetBits( EventGroupHandle_t group )
{
    return group->bits;
}
extern "C" EventBits_t xEventGroupWaitBits( EventGroupHandle_t group,
                                             EventBits_t wanted,
                                             BaseType_t clear,
                                             BaseType_t all,
                                             TickType_t timeout )
{
    last_timeout = timeout;
    const EventBits_t snapshot = group->bits;
    const EventBits_t matched = snapshot & wanted;
    const bool satisfied = all != pdFALSE ? matched == wanted : matched != 0U;
    if( satisfied && clear != pdFALSE ) group->bits &= ~wanted;
    return snapshot;
}
extern "C" void vEventGroupDelete( EventGroupHandle_t )
{
    ++deletes;
}

static_assert( std::is_enum< Ready >::value );
static_assert( !std::is_copy_constructible<
               freertos::EventGroup< Ready > >::value );

int main()
{
    using Mask = freertos::EventMask< Ready >;
    freertos::StaticEventGroupStorage storage {};
    {
        freertos::EventGroup< Ready > group { storage };
        assert( group.valid() && group.native_handle() == &storage.control );
        const Mask all = Mask { Ready::uart } | Mask { Ready::gpio } |
                         Mask { Ready::app };
        assert( group.set( Mask { Ready::uart } ).raw() == 1U );
        assert( group.set( Mask { Ready::uart } ).raw() == 1U );
        auto result = group.wait(
            all, freertos::WaitMode::all, freertos::ClearMode::keep, 3U );
        assert( !result.satisfied( all, freertos::WaitMode::all ) );
        assert( last_timeout == 3U );
        assert( group.set( Mask { Ready::gpio } | Mask { Ready::app } ).raw() == 7U );
        result = group.wait(
            all, freertos::WaitMode::all, freertos::ClearMode::keep, 0U );
        assert( result.satisfied( all, freertos::WaitMode::all ) );
        assert( group.clear( Mask { Ready::gpio } ).raw() == 7U );
        assert( group.bits().raw() == 5U );
        const Mask any = Mask { Ready::uart } | Mask { Ready::app };
        result = group.wait(
            any, freertos::WaitMode::any,
            freertos::ClearMode::clear_on_exit, 0U );
        assert( result.observed.raw() == 5U );
        assert( result.satisfied( any, freertos::WaitMode::any ) );
        assert( group.bits().raw() == 0U );
    }
    assert( deletes == 1U );
}