void TimepixProducer::OnStopRun()
{
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("End Of Run."));

	if ( GetRunStatusFlag() == TimepixProducer::RUN_STOPPED )
	{
		// give a warning to eudaq and do nothing
	    EUDAQ_WARN("StopRun requested when run not active");
		SetStatus(eudaq::Status::LVL_WARN, "StopRun requested when run not active");
	}
	else
	{
		// send STOP_RUN command to the daq thread
		PushCommand( STOP_RUN );

		// wait for the daq thread to lower the run active flag
		while ( GetRunStatusFlag() == RUN_ACTIVE )
		{
			Sleep(1);
		}
		
		//EUDAQ_DEBUG("Sending EORE");
		Sleep(1000);
		SendEvent(eudaq::RawDataEvent::EORE(_T("Timepix"),GetRunNumber(), GetEventNumber()));
		//std::cout << "Stop Run" << std::endl;
		//MessageBox(NULL, "End Of Run", "Message from Runcontrol",NULL);
		EUDAQ_INFO("Run Stopped");
		SetStatus(eudaq::Status::LVL_OK, "Run Stopped");

	}
}

    void ArAIProperty::CommandMoveTo(ArObjID targetID, float range /*= 0.0f*/)
    {
        if (!mAIList.empty())
        {
            if (mAIList.front()->GetType() == ENUM_AI_TYPE_MOVETOTARGET)
                return;
        }

        if (ArGameApp::Get()->GetEntityManager()->IsHero(GetEntity<ArGameEntity>()->GetID()))
        {
            double time = Driver->GetElapsedSecond();
            if (time - mLastMoveTime < DEF_AI_MOVE_REQUEST_MIN_TIME)
            {
                return;
            }
            mLastMoveTime = time;
        }
        if (GetEntity<ArGameEntity>()->IsDead())
        {
            return;
        }
        ClearAIList();

        auto pCmd = DI_NEW ArAIMoveToTargetCommand(mEntity, targetID, range);
        PushCommand(pCmd);
    }

void System_AskForPermission(SystemPermission permission) {
	switch (permission) {
	case SYSTEM_PERMISSION_STORAGE:
		PushCommand("ask_permission", "storage");
		break;
	}
}

void UFlareSpacecraftNavigationSystem::PushCommandLinearBrake(const FVector& VelocityTarget)
{
	FFlareShipCommandData Command;
	Command.Type = EFlareCommandDataType::CDT_BrakeLocation;
	Command.VelocityTarget = VelocityTarget;
	PushCommand(Command);
}

void TimepixProducer::OnReset()
{
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("Reset."));
	PushCommand( RESET );
	
	//std::cout << "Reset" << std::endl;
    //SetStatus(eudaq::Status::LVL_OK);
}

 void Controller::Resize(uint32_t width, uint32_t height) {
     if (mStatus == State::kRunning || mStatus == State::kPaused) {
         Command cmd(Cmd::kResize);
         cmd.arg1 = width;
         cmd.arg2 = height;
         PushCommand(cmd);
     }
 }

 void Controller::Resume() {
     if (mStatus == State::kPaused) {
         std::unique_lock<std::mutex> locker(mConditionMutex);
         mStatus = State::kRunning;
         PushCommand(Cmd::kResume);
         mCondition.notify_all();
     }
 }

internal rc_set_camera_matrix*
PushSetCameraMatrix(render_buffer* RenderBuffer, mat4 Matrix)
{
    rc_set_camera_matrix Command = {0};
    Command.Matrix               = Matrix;

    return (rc_set_camera_matrix*)PushCommand(RenderBuffer, RenderCommand_SetCameraMatrix, &Command);
}

internal rc_load_texture*
PushLoadTexture(render_buffer* RenderBuffer, texture_slot* TextureSlot, bool32 Interpolate, char* Filename)
{
    rc_load_texture Command = {0};
    Command.TextureSlot     = TextureSlot;
    Command.Filename        = Filename;

    return (rc_load_texture*)PushCommand(RenderBuffer, RenderCommand_LoadTexture, &Command);
}

void TimepixProducer::OnTerminate()
{	
	DEVID devId = pixelmanCtrl->mpxDevId[pixelmanCtrl->mpxCurrSel].deviceId;
	pixelmanCtrl->mpxCtrlAbortOperation(devId);
	pixelmanCtrl->m_commHistRunCtrl.AddString(_T("Terminated (I'll be back)"));
	//std::cout << "Terminate (press enter)" << std::endl;
    SetDone( true );
	PushCommand( TERMINATE );
	
}

internal rc_draw_rect_multitextured*
PushDrawRectMultitextured(render_buffer* RenderBuffer, vec2 Mid, vec2 Size)
{
    rc_draw_rect_multitextured Command = {0};
    Command.Mid                        = Mid;
    Command.Size                       = Size;
    Command.Color                      = Vec4i(1, 1, 1, 1);

    return (rc_draw_rect_multitextured*)PushCommand(RenderBuffer, RenderCommand_DrawRectMultitextured, &Command);
}

internal rc_draw_rect_outline*
PushDrawRectOutline(render_buffer* RenderBuffer, vec2 Mid, vec2 Size, vec4 Color)
{
    rc_draw_rect_outline Command = {0};
    Command.Mid                  = Mid;
    Command.Size                 = Size;
    Command.Color                = Color;

    return (rc_draw_rect_outline*)PushCommand(RenderBuffer, RenderCommand_DrawRectOutline, &Command);
}

internal rc_draw_line*
PushDrawLine(render_buffer* RenderBuffer, vec2 Start, vec2 End, vec4 Color)
{
    rc_draw_line Command = {0};
    Command.Start        = Start;
    Command.End          = End;
    Command.Color        = Color;

    return (rc_draw_line*)PushCommand(RenderBuffer, RenderCommand_DrawLine, &Command);
}

internal rc_load_font*
PushLoadFont(render_buffer* RenderBuffer, font_slot* FontSlot, char* Filename, float Height)
{
    rc_load_font Command = {0};
    Command.FontSlot     = FontSlot;
    Command.Filename     = Filename;
    Command.Height       = Height;
    Command.OversampleX  = 2;
    Command.OversampleY  = 2;

    return (rc_load_font*)PushCommand(RenderBuffer, RenderCommand_LoadFont, &Command);
}

    void Controller::Stop() {
        if (mStatus == State::kRunning || mStatus == State::kPaused) {
            if (mStatus == State::kPaused) {
                Resume();
            }

            PushCommand(Cmd::kStop);
            if (mWorker.joinable()) {
                mWorker.join();
            }
        }
    }

internal rc_draw_rect*
PushDrawRect(render_buffer* RenderBuffer, vec2 Mid, vec2 Size, texture_slot* TextureSlot)
{
    rc_draw_rect Command = {0};
    Command.Mid          = Mid;
    Command.Size         = Size;
    Command.Color        = Vec4i(1, 1, 1, 1);
    Command.TextureSlot  = TextureSlot;
    Command.MinUV        = Vec2i(0, 0);
    Command.MaxUV        = Vec2i(1, 1);

    return (rc_draw_rect*)PushCommand(RenderBuffer, RenderCommand_DrawRect, &Command);
}

void UFlareSpacecraftNavigationSystem::PushCommandRotation(const FVector& RotationTarget, const FVector& LocalShipAxis)
{
	if (RotationTarget.IsNearlyZero() || LocalShipAxis.IsNearlyZero())
	{
		return;
	}

	FFlareShipCommandData Command;
	Command.Type = EFlareCommandDataType::CDT_Rotation;
	Command.RotationTarget = RotationTarget;
	Command.LocalShipAxis = LocalShipAxis;
	FLOGV("UFlareSpacecraftNavigationSystem::PushCommandRotation RotationTarget '%s'", *RotationTarget.ToString());
	FLOGV("UFlareSpacecraftNavigationSystem::PushCommandRotation LocalShipAxis '%s'", *LocalShipAxis.ToString());
	PushCommand(Command);
}

internal rc_load_texture_raw*
PushLoadTextureRaw(render_buffer* RenderBuffer,
                   texture_slot* TextureSlot,
                   bool32 Interpolate,
                   uint8* Data,
                   uint32 Width,
                   uint32 Height)
{
    rc_load_texture_raw Command = {0};
    Command.TextureSlot         = TextureSlot;
    Command.Data                = Data;
    Command.Width               = Width;
    Command.Height              = Height;

    return (rc_load_texture_raw*)PushCommand(RenderBuffer, RenderCommand_LoadTextureRaw, &Command);
}

void ThreadCommandQueue::PushExitCommand(bool wait)
{
    // Exit is processed in two stages:
    //  - First, ExitEnqueued flag is set to block further commands from queuing up.
    //  - Second, the actual exit call is processed on the consumer thread, flushing
    //    any prior commands.
    //    IsExiting() only returns true after exit has flushed.
    {
        Lock::Locker lock(&pImpl->QueueLock);
        if (pImpl->ExitEnqueued)
            return;
        pImpl->ExitEnqueued = true;
    }

    PushCommand(ThreadCommandQueueImpl::ExitCommand(pImpl, wait));
}

internal rc_draw_string*
PushDrawString(render_buffer* RenderBuffer, font_slot* FontSlot, vec2 Pos, float Scale, char* String)
{
    rc_draw_string Command = {0};
    Command.FontSlot       = FontSlot;
    Command.Pos            = Pos;
    Command.Color          = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
    Command.Scale          = Scale;

    rc_draw_string* Result = (rc_draw_string*)PushCommand(RenderBuffer, RenderCommand_DrawString, &Command);
    while(*String)
    {
        *RenderBuffer->Current = (u8)*String;
        ++RenderBuffer->Current;
        ++Result->CharCount;
    }
    return (Result);
}