/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * OS X Server Event Handling

 *

 * 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.

 */

#include <dispatch/dispatch.h>

#include <CoreGraphics/CoreGraphics.h>

#include <CoreVideo/CoreVideo.h>

#include <IOKit/IOKitLib.h>

#include <IOSurface/IOSurface.h>

#include "mf_mountain_lion.h"

dispatch_semaphore_t region_sem;

dispatch_semaphore_t data_sem;

dispatch_queue_t screen_update_q;

CGDisplayStreamRef stream;

CGDisplayStreamUpdateRef lastUpdate = NULL;

BYTE* localBuf = NULL;

BOOL ready = FALSE;

void (^streamHandler)(CGDisplayStreamFrameStatus, uint64_t, IOSurfaceRef, CGDisplayStreamUpdateRef) =  ^(CGDisplayStreamFrameStatus status, uint64_t displayTime, IOSurfaceRef frameSurface, CGDisplayStreamUpdateRef updateRef)

{

	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);

	//may need to move this down

	if(ready == TRUE)

	{

		RFX_RECT rect;

		unsigned long offset_beg;

		unsigned long stride;

		int i;

		rect.x = 0;

		rect.y = 0;

		rect.width = 0;

		rect.height = 0;

		mf_mlion_peek_dirty_region(&rect);

		//lock surface

		IOSurfaceLock(frameSurface, kIOSurfaceLockReadOnly, NULL);

		//get pointer

		void* baseAddress = IOSurfaceGetBaseAddress(frameSurface);

		//copy region

		stride = IOSurfaceGetBytesPerRow(frameSurface);

		//memcpy(localBuf, baseAddress + offset_beg, surflen);

		for(i = 0; i < rect.height; i++)

		{

			offset_beg = (stride * (rect.y + i) + (rect.x * 4));

			memcpy(localBuf + offset_beg,

			       baseAddress + offset_beg,

			       rect.width * 4);

		}

		//unlock surface

		IOSurfaceUnlock(frameSurface, kIOSurfaceLockReadOnly, NULL);

		ready = FALSE;

		dispatch_semaphore_signal(data_sem);

	}

	if (status != kCGDisplayStreamFrameStatusFrameComplete)

	{

		switch(status)

		{

			case kCGDisplayStreamFrameStatusFrameIdle:

				break;

			case kCGDisplayStreamFrameStatusStopped:

				break;

			case kCGDisplayStreamFrameStatusFrameBlank:

				break;

			default:

				break;

		}

	}

	else if (lastUpdate == NULL)

	{

		CFRetain(updateRef);

		lastUpdate = updateRef;

	}

	else

	{

		CGDisplayStreamUpdateRef tmpRef;

		tmpRef = lastUpdate;

		lastUpdate = CGDisplayStreamUpdateCreateMergedUpdate(tmpRef, updateRef);

		CFRelease(tmpRef);

	}

	dispatch_semaphore_signal(region_sem);

};

int mf_mlion_display_info(UINT32* disp_width, UINT32* disp_height, UINT32* scale)

{

	CGDirectDisplayID display_id;

	display_id = CGMainDisplayID();

	CGDisplayModeRef mode = CGDisplayCopyDisplayMode(display_id);

	size_t pixelWidth = CGDisplayModeGetPixelWidth(mode);

	//size_t pixelHeight = CGDisplayModeGetPixelHeight(mode);

	size_t wide = CGDisplayPixelsWide(display_id);

	size_t high = CGDisplayPixelsHigh(display_id);

	CGDisplayModeRelease(mode);

	*disp_width = wide;//pixelWidth;

	*disp_height = high;//pixelHeight;

	*scale = pixelWidth / wide;

	return 0;

}

int mf_mlion_screen_updates_init()

{

	CGDirectDisplayID display_id;

	display_id = CGMainDisplayID();

	screen_update_q = dispatch_queue_create("mfreerdp.server.screenUpdate", NULL);

	region_sem = dispatch_semaphore_create(1);

	data_sem = dispatch_semaphore_create(1);

	UINT32 pixelWidth;

	UINT32 pixelHeight;

	UINT32 scale;

	mf_mlion_display_info(&pixelWidth, &pixelHeight, &scale);

	localBuf = malloc(pixelWidth * pixelHeight * 4);

	if (!localBuf)

		return -1;

	CFDictionaryRef opts;

	void * keys[2];

	void * values[2];

	keys[0] = (void *) kCGDisplayStreamShowCursor;

	values[0] = (void *) kCFBooleanFalse;

	opts = CFDictionaryCreate(kCFAllocatorDefault, (const void **) keys, (const void **) values, 1, NULL, NULL);

	stream = CGDisplayStreamCreateWithDispatchQueue(display_id,

							pixelWidth,

							pixelHeight,

							'BGRA',

							opts,

							screen_update_q,

							streamHandler);

	CFRelease(opts);

	return 0;

}

int mf_mlion_start_getting_screen_updates()

{

	CGError err;

	err = CGDisplayStreamStart(stream);

	if (err != kCGErrorSuccess)

	{

		return 1;

	}

	return 0;

}

int mf_mlion_stop_getting_screen_updates()

{

	CGError err;

	err = CGDisplayStreamStop(stream);

	if (err != kCGErrorSuccess)

	{

		return 1;

	}

	return 0;

}

int mf_mlion_get_dirty_region(RFX_RECT* invalid)

{

	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);

	if (lastUpdate != NULL)

	{

		mf_mlion_peek_dirty_region(invalid);

	}

	dispatch_semaphore_signal(region_sem);

	return 0;

}

int mf_mlion_peek_dirty_region(RFX_RECT* invalid)

{

	size_t num_rects, i;

	CGRect dirtyRegion;

	const CGRect * rects = CGDisplayStreamUpdateGetRects(lastUpdate, kCGDisplayStreamUpdateDirtyRects, &num_rects);

	if (num_rects == 0) {

		return 0;

	}

	dirtyRegion = *rects;

	for (i = 0; i < num_rects; i++)

	{

		dirtyRegion = CGRectUnion(dirtyRegion, *(rects+i));

	}

	invalid->x = dirtyRegion.origin.x;

	invalid->y = dirtyRegion.origin.y;

	invalid->height = dirtyRegion.size.height;

	invalid->width = dirtyRegion.size.width;

	return 0;

}

int mf_mlion_clear_dirty_region()

{

	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);

	CFRelease(lastUpdate);

	lastUpdate = NULL;

	dispatch_semaphore_signal(region_sem);

	return 0;

}

int mf_mlion_get_pixelData(long x, long y, long width, long height, BYTE** pxData)

{

	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);

	ready = TRUE;

	dispatch_semaphore_wait(data_sem, DISPATCH_TIME_FOREVER);

	dispatch_semaphore_signal(region_sem);

	//this second wait allows us to block until data is copied... more on this later

	dispatch_semaphore_wait(data_sem, DISPATCH_TIME_FOREVER);

	*pxData = localBuf;

	dispatch_semaphore_signal(data_sem);

	return 0;

}