#include <cassert>
#include <type_traits>

#include "freertos/task_storage.hpp"

namespace
{
size_t dynamic_calls;
size_t static_calls;
void * dynamic_context;
void * static_context;
int dynamic_tcb;

class DynamicProbe final : public freertos::DynamicTask< DynamicProbe >
{
    friend class freertos::DynamicTask< DynamicProbe >;
public:
    constexpr DynamicProbe() : DynamicTask { "dyn", 64U, 2U } {}
private:
    void run() {}
};

class StaticProbe final : public freertos::StaticTask< StaticProbe, 64U >
{
    friend class freertos::StaticTask< StaticProbe, 64U >;
public:
    explicit constexpr StaticProbe(
        freertos::StaticTaskStorage< 64U > & storage )
        : StaticTask { "stat", 2U, storage } {}
private:
    void run() {}
};
} // namespace

extern "C" BaseType_t xTaskCreate( TaskFunction_t, const char *,
                                    configSTACK_DEPTH_TYPE, void * context,
                                    UBaseType_t, TaskHandle_t * handle )
{
    ++dynamic_calls;
    dynamic_context = context;
    *handle = &dynamic_tcb;
    return pdPASS;
}
extern "C" TaskHandle_t xTaskCreateStatic(
    TaskFunction_t, const char *, configSTACK_DEPTH_TYPE, void * context,
    UBaseType_t, StackType_t *, StaticTask_t * tcb )
{
    ++static_calls;
    static_context = context;
    return tcb;
}
extern "C" void vTaskDelete( TaskHandle_t ) {}

static_assert( !std::is_copy_constructible< DynamicProbe >::value );
static_assert( !std::is_move_constructible< StaticProbe >::value );
static_assert( !std::is_polymorphic< DynamicProbe >::value );
static_assert( !std::is_polymorphic< StaticProbe >::value );

int main()
{
    freertos::StaticTaskStorage< 64U > storage {};
    DynamicProbe dynamic;
    StaticProbe statik { storage };
    assert( dynamic_calls == 0U && static_calls == 0U );
    assert( dynamic.start() );
    assert( dynamic_calls == 1U && dynamic_context == &dynamic );
    assert( dynamic.native_handle() == &dynamic_tcb );
    assert( statik.start() );
    assert( static_calls == 1U && static_context == &statik );
    assert( statik.native_handle() == &storage.tcb );
    assert( statik.tcb_storage() == &storage.tcb );
    assert( statik.stack_storage() == storage.stack );
    assert( statik.stack_words() == 64U );
    assert( statik.stack_bytes() == 64U * sizeof( StackType_t ) );
    assert( !dynamic.start() && !statik.start() );
    return 0;
}