void NOD_Idle::onEnter( const BTInputParam &input )
{
	const BlackBoard &inputData = input.getRealData<BlackBoard>();

	auto self = inputData.self;

	self->idle();
	this->finish();
	/*
	self->runAction(Sequence::create(DelayTime::create(1.0f), CallFunc::create([=]() {
		this->finish();
	}), nullptr));
	*/
}

int main(int argc, char *argv[])
{
    
    init();
    
    glfwInit();
    
    window = glfwCreateWindow(1024, 1024, "OpenGL", nullptr, nullptr); // Windowed
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);
	glClearColor(0.8f, 0.8f, 0.8f, 0.8f);
    while(!glfwWindowShouldClose(window)){
        
        float ratio;
        int width, height;
       
        glfwGetFramebufferSize(window, &width, &height);
        ratio = width / (float) height;
        
        glViewport(0, 0, width, height);
        glClear(GL_COLOR_BUFFER_BIT);
        
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glOrtho(-50.0, 562.0, -50.0, 562.0, -1, 1);
        
        box.DrawBox(show_grid);
		drawText();
        calculateAcceleration();
        handleInputs();
        display();
        idle();
        
        //Swap front and back buffers
        glfwSetWindowSizeCallback(window, reshape_window);
        glfwSwapBuffers(window);
        
        //Poll for and process events
        glfwPollEvents();
        
    }
    
    
    glfwDestroyWindow(window);
    glfwTerminate();
    
    return EXIT_SUCCESS;
    
}

// seg001:04D3
void __pascal far time_expired() {
	disable_keys = 1;
	set_hourglass_state(7);
	hourglass_sandflow = -1;
	play_sound(sound_36_out_of_time); // time over
	if (fade_in_1()) return;
	if (proc_cutscene_frame(2)) return;
	if (proc_cutscene_frame(100)) return;
	fade_out_1();
	while (check_sound_playing()) {
		idle();
		do_paused();
	}
}

int32_t Engine::run() {
    is_running_ = true;

    while(is_running_) {
        chapter_manager().current_chapter().frame_start();
        is_running_ = window().update();
        chapter_manager().current_chapter().frame_finish();

        idle().execute();
        timed().execute();
    }

    return 0;
}

int win32_windowed_app::run() {
    MSG msg = { 0 };
    msg.message = WM_NULL;
    while (msg.message != WM_QUIT) {
        if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE) != 0) {
            ::TranslateMessage(&msg);
            ::DispatchMessage(&msg);
        }
        else {
            idle();
        }
    }
    return msg.wParam;
}

list<Entity*> OverheadPlayer::update(float diff)
{
    list<Entity*> result;

    orientPlayer();

    Entity::update(diff);

    cooldown -= diff;
    if(cooldown<0) cooldown = 0;

    bool xflag = false;
    bool yflag = false;

    if(Keyboard::isKeyPressed(application->controls.getKey("Move Up")))
    {
        yflag = true;
        accelerateCenter(b2Vec2(0, -5.f));
    }
    if(Keyboard::isKeyPressed(application->controls.getKey("Move Down")))
    {
        yflag = true;
        accelerateCenter(b2Vec2(0, 5.f));
    }
    if(Keyboard::isKeyPressed(application->controls.getKey("Move Right")))
    {
        xflag = true;
        accelerateCenter(b2Vec2(5.f, 0.f));
    }
    if(Keyboard::isKeyPressed(application->controls.getKey("Move Left")))
    {
        accelerateCenter(b2Vec2(-5.f, 0.f));
        xflag = true;
    }
    if(Mouse::isButtonPressed(application->controls.getMouseButton("Shoot")))
    {
        if(cooldown==0)
            result.push_back(shoot());
    }

    if(!xflag && !yflag)
    {
        idle();
    }

    if(!xflag) decelerateX();
    if(!yflag) decelerateY();

    return result;
}

/**
 * RSID function for use during testing. Not for flight
 */
void rsid_test(void)
{
  while (1) {

   telemetry_start_rsid(RSID_CONTESTIA_32_1000);

   // Sleep wait for RSID
   while (telemetry_active()) {
     idle(IDLE_TELEMETRY_ACTIVE);
   }

    for (int i = 3*200*1000; i; i--);
  }
}

void suspend_power_down(void)
{
#ifdef NO_SUSPEND_POWER_DOWN
    ;
#elif defined(SUSPEND_MODE_NOPOWERSAVE)
    ;
#elif defined(SUSPEND_MODE_STANDBY)
    standby();
#elif defined(SUSPEND_MODE_IDLE)
    idle();
#else
    power_down(WDTO_15MS);
#endif
}

void MadsPlayer::nextFrame() {
	if (_madsVm->_currentTimer >= (_priorTimer + _ticksAmount)) {
		_priorTimer = _madsVm->_currentTimer;

		if (_moving)
			move();
		else
			idle();

		// Post update logic
		if (_moving) {
			++_frameNum;
			if (_frameNum > _frameCount)
				_frameNum = 1;
			_forceRefresh = true;
		} else if (!_forceRefresh) {
			idle();
		}

		// Final update
		update();
	}
}

////////////////////////////////////////////////////////////////////////////////
// delay
// PURPOSE: Blocks for a given number of seconds.
// PARAMS:  (IN) int time - number of seconds to delay.
// RETURNS: Nothing.
// NOTES:   Unreliable before init_timer is run.
////////////////////////////////////////////////////////////////////////////////
void
delay(int time){
  u32 now = 0;
 
  now = get_time_timer();
  while(time--)
  {
    while(now == get_time_timer())
    {
       idle();
    }
    now = get_time_timer();
  }
}

void cpu_idle (void)
{
	
	while (1) {
		while (!need_resched()) {
			void (*idle)(void);
			idle = pm_idle;
			if (!idle)
				idle = default_idle;
			idle();
		}
		schedule_preempt_disabled();
	}
}

void DW1000Class::softReset() {
	byte pmscctrl0[LEN_PMSC_CTRL0];
	readBytes(PMSC, PMSC_CTRL0_SUB, pmscctrl0, LEN_PMSC_CTRL0);
	pmscctrl0[0] = 0x01;
	writeBytes(PMSC, PMSC_CTRL0_SUB, pmscctrl0, LEN_PMSC_CTRL0);
	pmscctrl0[3] = 0x00;
	writeBytes(PMSC, PMSC_CTRL0_SUB, pmscctrl0, LEN_PMSC_CTRL0);
	delay(10);
	pmscctrl0[0] = 0x00;
	pmscctrl0[3] = 0xF0;
	writeBytes(PMSC, PMSC_CTRL0_SUB, pmscctrl0, LEN_PMSC_CTRL0);
	// force into idle mode
	idle();
}

s32 sys_exit()
{
    u32 eflags;

    _local_irq_save(eflags);
    if (task_list[current].pwait != 0) 
        task_wakeup(task_list[current].pwait);

    task_list[current].state = TASK_STOPED;
    _local_irq_restore(eflags);

    /* 等待0号任务清空 */
    while(1){idle();};
}

/* ARGSUSED1 */
void
keyboard(unsigned char ch, int x, int y)
{
  switch (ch) {
  case 27:             /* escape */
    exit(0);
    break;
  case ' ':
    if (!moving) {
      idle();
      glutPostRedisplay();
    }
  }
}

unsigned char ftDigital (unsigned short port) {
  unsigned char result = 0;
#ifdef _WIN32
  unsigned short status = port+1;
  int enabled = ftDisable && _disable();
#endif
#ifdef SC12
  unsigned short status = port;
#endif
  int bit = 8;
  int data = triggerX|triggerY|loadIn;
  if (ftLoadOut) data |= loadOut;
  
  trace(8, ("digital %03x", port));
  trace(32, (" >%02x", data));
  _outp(port, data); idle(ftIdle);
  data |= clock;
  trace(32, (" >%02x", data));
  _outp(port, data);
  while (bit-- > 0) {
    idle(ftIdle);
    result |= ((_inp(status) & busy) != 0) << bit;
    trace(16, (" <%02x", result));
    data = triggerX|triggerY;
    if (ftLoadOut) data |= loadOut;
    trace(32, (" >%02x", data));
    _outp(port, data); idle(ftIdle);
    data |= clock;
    trace(32, (" >%02x", data));
    _outp(port, data);
  }
  trace(8, (" %02x\n", result));
#ifdef _WIN32
  if (enabled) _enable();
#endif
  return result;
}

bool SignalHandler::waitForEvent(pdvector<EventRecord> &events_to_handle)
{
    assert(waitLock);

    signal_printf("%s[%d]: waitForEvent, events_to_handle(%d), idle_flag %d\n",
                  FILE__, __LINE__, events_to_handle.size(), idle());

    while (idle()) {
        // Our eventlocks are paired mutexes and condition variables; this
        // is actually _not_ what we want because we want to be able to
        // wait on different things but have the same global mutex. So we fake it
        // by carefully unlocking and relocking things. 
        
        // We now wait until _we_ are signalled by the generator; so we grab
        // our signal lock, give up the global mutex lock, and then wait; after
        // we're signalled we take the global mutex before giving up our own 
        // waitLock.
        
        waitingForWakeup_ = true;
        signal_printf("%s[%d]: acquiring waitLock lock...\n", FILE__, __LINE__);
        waitLock->_Lock(FILE__, __LINE__);
        signal_printf("%s[%d]: releasing global mutex...\n", FILE__, __LINE__);
        assert(eventlock->depth() == 1);
        eventlock->_Unlock(FILE__, __LINE__);
        
        signal_printf("%s[%d]: sleeping for activation\n", FILE__, __LINE__);
        waitLock->_WaitForSignal(FILE__, __LINE__);
        
        signal_printf("%s[%d]: woken, reacquiring global lock...\n", FILE__, __LINE__);
        eventlock->_Lock(FILE__, __LINE__);
        signal_printf("%s[%d]: woken, releasing waitLock...\n", FILE__, __LINE__);
        waitLock->_Unlock(FILE__, __LINE__);
        waitingForWakeup_ = false;        
    }
    
    return true;
}

extern void
USO_transform (void (*run) (void), USO_stack_t * stack, int stack_size)
{
    USO_list_init (&interrupt_threads);
    USO_list_init (&system_threads);
    USO_list_init (&user_threads);
    USO_thread_init (&idle_thread, NULL, stack, stack_size, USO_IDLE, USO_FIFO, "idle");
    USO_thread_in_init (&idle_thread, NULL);
    USO_thread_out_init (&idle_thread, NULL);
    USO_thread_work_set (&idle_thread, NULL);
    current_thread = &idle_thread;
    old_thread = &idle_thread;
    run ();
    idle ();
}

/*
 * The idle thread. There's no useful work to be
 * done, so just try to conserve power and have a
 * low exit latency (ie sit in a loop waiting for
 * somebody to say that they'd like to reschedule)
 */
void cpu_idle (void)
{
	/* endless idle loop with no priority at all */
	while (1) {
		while (!need_resched()) {
			void (*idle)(void) = pm_idle;

			if (!idle)
				idle = default_idle;

			idle();
		}
		schedule_preempt_disabled();
	}
}

// Modbus Master State Machine
void modbus_update() 
{
	switch (state)
	{
		case IDLE:
		idle();
		break;
		case WAITING_FOR_REPLY:
		waiting_for_reply();
		break;
		case WAITING_FOR_TURNAROUND:
		waiting_for_turnaround();
		break;
	}
}

static inline
int psdapl_recvlook_block(psdapl_con_info_t *ci, void **buf)
{
	int len;
	while (1) {
		len = psdapl_recvlook(ci, buf);
		if (len >= 0) return len;

		if (len != -EAGAIN) {
			printf("receive returned an error : %s\n", strerror(-len));
			exit(1);
		}
		idle();
	}
}