#include <cassert>
#include <cstdint>
#include <type_traits>

#include "freertos/task_ref.hpp"
#include "freertos/ticks.hpp"

namespace
{

struct FakeTask
{
    eTaskState state;
    UBaseType_t priority;
};

FakeTask first { eReady, 2U };
FakeTask second { eRunning, 3U };
TaskHandle_t current = &second;
TickType_t tick = 41U;

} // namespace

extern "C" TickType_t xTaskGetTickCount()
{
    return tick;
}

extern "C" TaskHandle_t xTaskGetCurrentTaskHandle()
{
    return current;
}

extern "C" eTaskState eTaskGetState( TaskHandle_t handle )
{
    return static_cast< FakeTask * >( handle )->state;
}

extern "C" UBaseType_t uxTaskPriorityGet( TaskHandle_t handle )
{
    return static_cast< FakeTask * >( handle )->priority;
}

extern "C" void vTaskPrioritySet( TaskHandle_t handle,
                                   UBaseType_t priority )
{
    static_cast< FakeTask * >( handle )->priority = priority;
}

static_assert( std::is_trivially_copyable< freertos::TaskRef >::value );
static_assert( sizeof( freertos::TaskRef ) == sizeof( TaskHandle_t ) );

int main()
{
    constexpr freertos::Ticks three { 3U };
    static_assert( three.count() == 3U );

    const auto now = freertos::TickPoint::now();
    assert( now.count() == 41U );
    assert( ( freertos::TickPoint { 1U } -
              freertos::TickPoint { UINT32_MAX } ).count() == 2U );

    freertos::TaskRef first_ref { &first };
    assert( first_ref.native_handle() == &first );
    assert( first_ref.state() == eReady );
    assert( first_ref.priority() == 2U );
    first_ref.set_priority( 4U );
    assert( first.priority == 4U );

    const freertos::TaskRef current_ref = freertos::TaskRef::current();
    assert( current_ref.native_handle() == &second );
    assert( current_ref.state() == eRunning );
    return 0;
}