/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Display Update Virtual Channel Extension

 *

 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>

 * Copyright 2016 David PHAM-VAN <d.phamvan@inuvika.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 <freerdp/config.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <winpr/crt.h>

#include <winpr/assert.h>

#include <winpr/synch.h>

#include <winpr/print.h>

#include <winpr/thread.h>

#include <winpr/stream.h>

#include <winpr/sysinfo.h>

#include <winpr/cmdline.h>

#include <winpr/collections.h>

#include <freerdp/addin.h>

#include <freerdp/client/channels.h>

#include "disp_main.h"

#include "../disp_common.h"

typedef struct

{

  GENERIC_DYNVC_PLUGIN base;

  DispClientContext* context;

  UINT32 MaxNumMonitors;

  UINT32 MaxMonitorAreaFactorA;

  UINT32 MaxMonitorAreaFactorB;

} DISP_PLUGIN;

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT

disp_send_display_control_monitor_layout_pdu(GENERIC_CHANNEL_CALLBACK* callback, UINT32 NumMonitors,

                                             const DISPLAY_CONTROL_MONITOR_LAYOUT* Monitors)

{

  UINT status = 0;

  wStream* s = NULL;

  DISP_PLUGIN* disp = NULL;

  UINT32 MonitorLayoutSize = 0;

  DISPLAY_CONTROL_HEADER header = { 0 };

  WINPR_ASSERT(callback);

  WINPR_ASSERT(Monitors || (NumMonitors == 0));

  disp = (DISP_PLUGIN*)callback->plugin;

  WINPR_ASSERT(disp);

  MonitorLayoutSize = DISPLAY_CONTROL_MONITOR_LAYOUT_SIZE;

  header.length = 8 + 8 + (NumMonitors * MonitorLayoutSize);

  header.type = DISPLAY_CONTROL_PDU_TYPE_MONITOR_LAYOUT;

  s = Stream_New(NULL, header.length);

  if (!s)

  {

    WLog_ERR(TAG, "Stream_New failed!");

    return CHANNEL_RC_NO_MEMORY;

  }

  if ((status = disp_write_header(s, &header)))

  {

    WLog_ERR(TAG, "Failed to write header with error %" PRIu32 "!", status);

    goto out;

  }

  if (NumMonitors > disp->MaxNumMonitors)

    NumMonitors = disp->MaxNumMonitors;

  Stream_Write_UINT32(s, MonitorLayoutSize); /* MonitorLayoutSize (4 bytes) */

  Stream_Write_UINT32(s, NumMonitors);       /* NumMonitors (4 bytes) */

  WLog_DBG(TAG, "NumMonitors=%" PRIu32 "", NumMonitors);

  for (UINT32 index = 0; index < NumMonitors; index++)

  {

    DISPLAY_CONTROL_MONITOR_LAYOUT current = Monitors[index];

    current.Width -= (current.Width % 2);

    if (current.Width < 200)

      current.Width = 200;

    if (current.Width > 8192)

      current.Width = 8192;

    if (current.Width % 2)

      current.Width++;

    if (current.Height < 200)

      current.Height = 200;

    if (current.Height > 8192)

      current.Height = 8192;

    Stream_Write_UINT32(s, current.Flags);              /* Flags (4 bytes) */

    Stream_Write_UINT32(s, current.Left);               /* Left (4 bytes) */

    Stream_Write_UINT32(s, current.Top);                /* Top (4 bytes) */

    Stream_Write_UINT32(s, current.Width);              /* Width (4 bytes) */

    Stream_Write_UINT32(s, current.Height);             /* Height (4 bytes) */

    Stream_Write_UINT32(s, current.PhysicalWidth);      /* PhysicalWidth (4 bytes) */

    Stream_Write_UINT32(s, current.PhysicalHeight);     /* PhysicalHeight (4 bytes) */

    Stream_Write_UINT32(s, current.Orientation);        /* Orientation (4 bytes) */

    Stream_Write_UINT32(s, current.DesktopScaleFactor); /* DesktopScaleFactor (4 bytes) */

    Stream_Write_UINT32(s, current.DeviceScaleFactor);  /* DeviceScaleFactor (4 bytes) */

    WLog_DBG(TAG,

             "\t%" PRIu32 " : Flags: 0x%08" PRIX32 " Left/Top: (%" PRId32 ",%" PRId32

             ") W/H=%" PRIu32 "x%" PRIu32 ")",

             index, current.Flags, current.Left, current.Top, current.Width, current.Height);

    WLog_DBG(TAG,

             "\t   PhysicalWidth: %" PRIu32 " PhysicalHeight: %" PRIu32 " Orientation: %" PRIu32

             "",

             current.PhysicalWidth, current.PhysicalHeight, current.Orientation);

  }

out:

  Stream_SealLength(s);

  status = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),

                                    NULL);

  Stream_Free(s, TRUE);

  return status;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_recv_display_control_caps_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)

{

  DISP_PLUGIN* disp = NULL;

  DispClientContext* context = NULL;

  UINT ret = CHANNEL_RC_OK;

  WINPR_ASSERT(callback);

  WINPR_ASSERT(s);

  disp = (DISP_PLUGIN*)callback->plugin;

  WINPR_ASSERT(disp);

  context = disp->context;

  WINPR_ASSERT(context);

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))

    return ERROR_INVALID_DATA;

  Stream_Read_UINT32(s, disp->MaxNumMonitors);        /* MaxNumMonitors (4 bytes) */

  Stream_Read_UINT32(s, disp->MaxMonitorAreaFactorA); /* MaxMonitorAreaFactorA (4 bytes) */

  Stream_Read_UINT32(s, disp->MaxMonitorAreaFactorB); /* MaxMonitorAreaFactorB (4 bytes) */

  if (context->DisplayControlCaps)

    ret = context->DisplayControlCaps(context, disp->MaxNumMonitors,

                                      disp->MaxMonitorAreaFactorA, disp->MaxMonitorAreaFactorB);

  return ret;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_recv_pdu(GENERIC_CHANNEL_CALLBACK* callback, wStream* s)

{

  UINT32 error = 0;

  DISPLAY_CONTROL_HEADER header = { 0 };

  WINPR_ASSERT(callback);

  WINPR_ASSERT(s);

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))

    return ERROR_INVALID_DATA;

  if ((error = disp_read_header(s, &header)))

  {

    WLog_ERR(TAG, "disp_read_header failed with error %" PRIu32 "!", error);

    return error;

  }

  if (!Stream_EnsureRemainingCapacity(s, header.length))

  {

    WLog_ERR(TAG, "not enough remaining data");

    return ERROR_INVALID_DATA;

  }

  switch (header.type)

  {

    case DISPLAY_CONTROL_PDU_TYPE_CAPS:

      return disp_recv_display_control_caps_pdu(callback, s);

    default:

      WLog_ERR(TAG, "Type %" PRIu32 " not recognized!", header.type);

      return ERROR_INTERNAL_ERROR;

  }

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)

{

  GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;

  return disp_recv_pdu(callback, data);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_on_close(IWTSVirtualChannelCallback* pChannelCallback)

{

  free(pChannelCallback);

  return CHANNEL_RC_OK;

}

/**

 * Channel Client Interface

 */

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_send_monitor_layout(DispClientContext* context, UINT32 NumMonitors,

                                     DISPLAY_CONTROL_MONITOR_LAYOUT* Monitors)

{

  DISP_PLUGIN* disp = NULL;

  GENERIC_CHANNEL_CALLBACK* callback = NULL;

  WINPR_ASSERT(context);

  disp = (DISP_PLUGIN*)context->handle;

  WINPR_ASSERT(disp);

  callback = disp->base.listener_callback->channel_callback;

  return disp_send_display_control_monitor_layout_pdu(callback, NumMonitors, Monitors);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT disp_plugin_initialize(GENERIC_DYNVC_PLUGIN* base, rdpContext* rcontext,

                                   rdpSettings* settings)

{

  DispClientContext* context = NULL;

  DISP_PLUGIN* disp = (DISP_PLUGIN*)base;

  WINPR_ASSERT(disp);

  disp->MaxNumMonitors = 16;

  disp->MaxMonitorAreaFactorA = 8192;

  disp->MaxMonitorAreaFactorB = 8192;

  context = (DispClientContext*)calloc(1, sizeof(DispClientContext));

  if (!context)

  {

    WLog_Print(base->log, WLOG_ERROR, "unable to allocate DispClientContext");

    return CHANNEL_RC_NO_MEMORY;

  }

  context->handle = (void*)disp;

  context->SendMonitorLayout = disp_send_monitor_layout;

  disp->base.iface.pInterface = disp->context = context;

  return CHANNEL_RC_OK;

}

static void disp_plugin_terminated(GENERIC_DYNVC_PLUGIN* base)

{

  DISP_PLUGIN* disp = (DISP_PLUGIN*)base;

  WINPR_ASSERT(disp);

  free(disp->context);

}

static const IWTSVirtualChannelCallback disp_callbacks = { disp_on_data_received, NULL, /* Open */

                                                         disp_on_close, NULL };

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

FREERDP_ENTRY_POINT(UINT disp_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))

{

  return freerdp_generic_DVCPluginEntry(pEntryPoints, TAG, DISP_DVC_CHANNEL_NAME,

                                        sizeof(DISP_PLUGIN), sizeof(GENERIC_CHANNEL_CALLBACK),

                                        &disp_callbacks, disp_plugin_initialize,

                                        disp_plugin_terminated);

}