/**
 * FreeRDP: A Remote Desktop Protocol Client
 * FreeRDP Windows Server
 *
 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2012 Corey Clayton <can.of.tuna@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>

#include <winpr/windows.h>

#include <freerdp/freerdp.h>
#include <freerdp/listener.h>

#include "wf_peer.h"
#include "wf_info.h"
#include "wf_mirage.h"

#include "wf_update.h"

#define TAG SERVER_TAG("windows")

DWORD WINAPI wf_update_thread(LPVOID lpParam)
{
	int index;
	int peerindex;
	DWORD fps;
	wfInfo* wfi;
	DWORD beg, end;
	DWORD diff, rate;
	wfi = (wfInfo*)lpParam;
	fps = wfi->framesPerSecond;
	rate = 1000 / fps;

	while (1)
	{
		beg = GetTickCount();

		if (wf_info_lock(wfi) > 0)
		{
			if (wfi->activePeerCount > 0)
			{
				wf_info_update_changes(wfi);

				if (wf_info_have_updates(wfi))
				{
					wf_update_encode(wfi);
					// WLog_DBG(TAG, "Start of parallel sending");
					index = 0;

					for (peerindex = 0; peerindex < wfi->peerCount; peerindex++)
					{
						for (; index < FREERDP_SERVER_WIN_INFO_MAXPEERS; index++)
						{
							if (wfi->peers[index] && wfi->peers[index]->activated)
							{
								// WLog_DBG(TAG, "Setting event for %d of %d", index + 1,
								// wfi->activePeerCount);
								SetEvent(((wfPeerContext*)wfi->peers[index]->context)->updateEvent);
							}
						}
					}

					for (index = 0; index < wfi->activePeerCount; index++)
					{
						// WLog_DBG(TAG, "Waiting for %d of %d", index + 1, wfi->activePeerCount);
						// WaitForSingleObject(wfi->updateSemaphore, INFINITE);
						WaitForSingleObject(wfi->updateSemaphore, 1000);
					}

					// WLog_DBG(TAG, "End of parallel sending");
					wf_info_clear_invalid_region(wfi);
				}
			}

			wf_info_unlock(wfi);
		}

		end = GetTickCount();
		diff = end - beg;

		if (diff < rate)
		{
			Sleep(rate - diff);
		}
	}

	// WLog_DBG(TAG, "Exiting Update Thread");
	return 0;
}

void wf_update_encode(wfInfo* wfi)
{
	RFX_RECT rect;
	long height, width;
	BYTE* pDataBits = NULL;
	int stride;
	SURFACE_BITS_COMMAND* cmd;
	wf_info_find_invalid_region(wfi);
	cmd = &wfi->cmd;
	Stream_SetPosition(wfi->s, 0);
	wf_info_getScreenData(wfi, &width, &height, &pDataBits, &stride);
	rect.x = 0;
	rect.y = 0;
	rect.width = (UINT16)width;
	rect.height = (UINT16)height;
	// WLog_DBG(TAG, "x:%"PRId32" y:%"PRId32" w:%ld h:%ld", wfi->invalid.left, wfi->invalid.top,
	// width, height);
	Stream_Clear(wfi->s);

	if (!(rfx_compose_message(wfi->rfx_context, wfi->s, &rect, 1, pDataBits, width, height,
	                          stride)))
	{
		return;
	}

	wfi->frame_idx = wfi->rfx_context->frameIdx;
	cmd->destLeft = wfi->invalid.left;
	cmd->destTop = wfi->invalid.top;
	cmd->destRight = wfi->invalid.left + width;
	cmd->destBottom = wfi->invalid.top + height;
	cmd->bmp.bpp = 32;
	cmd->bmp.codecID = 3;
	cmd->bmp.width = width;
	cmd->bmp.height = height;
	cmd->bmp.bitmapDataLength = Stream_GetPosition(wfi->s);
	cmd->bmp.bitmapData = Stream_Buffer(wfi->s);
}

void wf_update_peer_send(wfInfo* wfi, wfPeerContext* context)
{
	freerdp_peer* client = ((rdpContext*)context)->peer;

	/* This happens when the RemoteFX encoder state is reset */

	if (wfi->frame_idx == 1)
		context->frame_idx = 0;

	/*
	 * When a new client connects, it is possible that old frames from
	 * from a previous encoding state remain. Those frames should be discarded
	 * as they will cause an error condition in mstsc.
	 */

	if ((context->frame_idx + 1) != wfi->frame_idx)
	{
		/* This frame is meant to be discarded */
		if (context->frame_idx == 0)
			return;

		/* This is an unexpected error condition */
		WLog_DBG(TAG, "Unexpected Frame Index: Actual: %d Expected: %d", wfi->frame_idx,
		         context->frame_idx + 1);
	}

	wfi->cmd.bmp.codecID = client->settings->RemoteFxCodecId;
	client->update->SurfaceBits(client->update->context, &wfi->cmd);
	context->frame_idx++;
}

void wf_update_encoder_reset(wfInfo* wfi)
{
	if (wf_info_lock(wfi) > 0)
	{
		WLog_DBG(TAG, "Resetting encoder");

		if (wfi->rfx_context)
		{
			rfx_context_reset(wfi->rfx_context, wfi->servscreen_width, wfi->servscreen_height);
		}
		else
		{
			wfi->rfx_context = rfx_context_new(TRUE);
			wfi->rfx_context->mode = RLGR3;
			wfi->rfx_context->width = wfi->servscreen_width;
			wfi->rfx_context->height = wfi->servscreen_height;
			rfx_context_set_pixel_format(wfi->rfx_context, PIXEL_FORMAT_BGRA32);
			wfi->s = Stream_New(NULL, 0xFFFF);
		}

		wf_info_invalidate_full_screen(wfi);
		wf_info_unlock(wfi);
	}
}

void wf_update_peer_activate(wfInfo* wfi, wfPeerContext* context)
{
	if (wf_info_lock(wfi) > 0)
	{
		if (wfi->activePeerCount < 1)
		{
#ifndef WITH_DXGI_1_2
			wf_mirror_driver_activate(wfi);
#endif
			ResumeThread(wfi->updateThread);
		}

		wf_update_encoder_reset(wfi);
		wfi->activePeerCount++;
		WLog_DBG(TAG, "Activating Peer Updates: %d", wfi->activePeerCount);
		wf_info_unlock(wfi);
	}
}

void wf_update_peer_deactivate(wfInfo* wfi, wfPeerContext* context)
{
	if (wf_info_lock(wfi) > 0)
	{
		freerdp_peer* client = ((rdpContext*)context)->peer;

		if (client->activated)
		{
			if (wfi->activePeerCount <= 1)
			{
				wf_mirror_driver_deactivate(wfi);
			}

			client->activated = FALSE;
			wfi->activePeerCount--;
			WLog_DBG(TAG, "Deactivating Peer Updates: %d", wfi->activePeerCount);
		}

		wf_info_unlock(wfi);
	}
}
