/**
 * 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;
}
