/*
 * Copyright © 2017 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "tu_private.h"
#include "tu_cs.h"
#include "util/disk_cache.h"
#include "util/strtod.h"
#include "vk_util.h"
#include "vk_format.h"
#include "util/debug.h"
#include "wsi_common_display.h"

VkResult
tu_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device,
                                         uint32_t *property_count,
                                         VkDisplayPropertiesKHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_properties(
             physical_device,
             &pdevice->wsi_device,
             property_count,
             properties);
}

VkResult
tu_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physical_device,
                                          uint32_t *property_count,
                                          VkDisplayProperties2KHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_properties2(
             physical_device,
             &pdevice->wsi_device,
             property_count,
             properties);
}

VkResult
tu_GetPhysicalDeviceDisplayPlanePropertiesKHR(
   VkPhysicalDevice physical_device,
   uint32_t *property_count,
   VkDisplayPlanePropertiesKHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_plane_properties(
             physical_device,
             &pdevice->wsi_device,
             property_count,
             properties);
}

VkResult
tu_GetPhysicalDeviceDisplayPlaneProperties2KHR(
   VkPhysicalDevice physical_device,
   uint32_t *property_count,
   VkDisplayPlaneProperties2KHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_plane_properties2(
             physical_device,
             &pdevice->wsi_device,
             property_count,
             properties);
}

VkResult
tu_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device,
                                       uint32_t plane_index,
                                       uint32_t *display_count,
                                       VkDisplayKHR *displays)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_display_plane_supported_displays(
             physical_device,
             &pdevice->wsi_device,
             plane_index,
             display_count,
             displays);
}


VkResult
tu_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device,
                               VkDisplayKHR display,
                               uint32_t *property_count,
                               VkDisplayModePropertiesKHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_display_mode_properties(physical_device,
                                                  &pdevice->wsi_device,
                                                  display,
                                                  property_count,
                                                  properties);
}

VkResult
tu_GetDisplayModeProperties2KHR(VkPhysicalDevice physical_device,
                                VkDisplayKHR display,
                                uint32_t *property_count,
                                VkDisplayModeProperties2KHR *properties)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_get_display_mode_properties2(physical_device,
                                                   &pdevice->wsi_device,
                                                   display,
                                                   property_count,
                                                   properties);
}

VkResult
tu_CreateDisplayModeKHR(VkPhysicalDevice physical_device,
                        VkDisplayKHR display,
                        const VkDisplayModeCreateInfoKHR *create_info,
                        const VkAllocationCallbacks *allocator,
                        VkDisplayModeKHR *mode)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_display_create_display_mode(physical_device,
                                          &pdevice->wsi_device,
                                          display,
                                          create_info,
                                          allocator,
                                          mode);
}

VkResult
tu_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device,
                                  VkDisplayModeKHR mode_khr,
                                  uint32_t plane_index,
                                  VkDisplayPlaneCapabilitiesKHR *capabilities)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_get_display_plane_capabilities(physical_device,
                                             &pdevice->wsi_device,
                                             mode_khr,
                                             plane_index,
                                             capabilities);
}

VkResult
tu_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physical_device,
                                   const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
                                   VkDisplayPlaneCapabilities2KHR *capabilities)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_get_display_plane_capabilities2(physical_device,
                                              &pdevice->wsi_device,
                                              pDisplayPlaneInfo,
                                              capabilities);
}

VkResult
tu_CreateDisplayPlaneSurfaceKHR(
   VkInstance _instance,
   const VkDisplaySurfaceCreateInfoKHR *create_info,
   const VkAllocationCallbacks *allocator,
   VkSurfaceKHR *surface)
{
   TU_FROM_HANDLE(tu_instance, instance, _instance);
   const VkAllocationCallbacks *alloc;

   if (allocator)
      alloc = allocator;
   else
      alloc = &instance->alloc;

   return wsi_create_display_surface(_instance, alloc,
                                     create_info, surface);
}

VkResult
tu_ReleaseDisplayEXT(VkPhysicalDevice physical_device,
                     VkDisplayKHR     display)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_release_display(physical_device,
                              &pdevice->wsi_device,
                              display);
}

#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
VkResult
tu_AcquireXlibDisplayEXT(VkPhysicalDevice     physical_device,
                         Display              *dpy,
                         VkDisplayKHR         display)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_acquire_xlib_display(physical_device,
                                   &pdevice->wsi_device,
                                   dpy,
                                   display);
}

VkResult
tu_GetRandROutputDisplayEXT(VkPhysicalDevice  physical_device,
                            Display           *dpy,
                            RROutput          output,
                            VkDisplayKHR      *display)
{
   TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device);

   return wsi_get_randr_output_display(physical_device,
                                       &pdevice->wsi_device,
                                       dpy,
                                       output,
                                       display);
}
#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */

/* VK_EXT_display_control */

VkResult
tu_DisplayPowerControlEXT(VkDevice                    _device,
                          VkDisplayKHR                display,
                          const VkDisplayPowerInfoEXT *display_power_info)
{
   TU_FROM_HANDLE(tu_device, device, _device);

   return wsi_display_power_control(_device,
                                    &device->physical_device->wsi_device,
                                    display,
                                    display_power_info);
}

static int
import_syncobj(int fd, uint32_t syncobj)
{
   struct drm_syncobj_handle handle = { .handle = syncobj };
   int ret;

   ret = ioctl(fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, &handle);
   if (ret)
      return 0;

   return ret ? -1 : handle.fd;
}

VkResult
tu_RegisterDeviceEventEXT(VkDevice                    _device,
                          const VkDeviceEventInfoEXT  *device_event_info,
                          const VkAllocationCallbacks *allocator,
                          VkFence                     *_fence)
{
   TU_FROM_HANDLE(tu_device, device, _device);
   VkResult ret;

   ret = tu_CreateFence(_device, &(VkFenceCreateInfo) {}, allocator, _fence);
   if (ret != VK_SUCCESS)
      return ret;

   TU_FROM_HANDLE(tu_fence, fence, *_fence);

   int sync_fd = import_syncobj(device->fd, fence->syncobj);
   if (sync_fd >= 0) {
      ret = wsi_register_device_event(_device,
                                      &device->physical_device->wsi_device,
                                      device_event_info,
                                      allocator,
                                      NULL,
                                      sync_fd);
   } else {
      ret = VK_ERROR_OUT_OF_HOST_MEMORY;
   }

   close(sync_fd);

   if (ret != VK_SUCCESS)
      tu_DestroyFence(_device, *_fence, allocator);

   return ret;
}

VkResult
tu_RegisterDisplayEventEXT(VkDevice                           _device,
                           VkDisplayKHR                       display,
                           const VkDisplayEventInfoEXT        *display_event_info,
                           const VkAllocationCallbacks        *allocator,
                           VkFence                            *_fence)
{
   TU_FROM_HANDLE(tu_device, device, _device);
   VkResult ret;

   ret = tu_CreateFence(_device, &(VkFenceCreateInfo) {}, allocator, _fence);
   if (ret != VK_SUCCESS)
      return ret;

   TU_FROM_HANDLE(tu_fence, fence, *_fence);

   int sync_fd = import_syncobj(device->fd, fence->syncobj);
   if (sync_fd >= 0) {
      ret = wsi_register_display_event(_device,
                                       &device->physical_device->wsi_device,
                                       display,
                                       display_event_info,
                                       allocator,
                                       NULL,
                                       sync_fd);
   } else {
      ret = VK_ERROR_OUT_OF_HOST_MEMORY;
   }

   close(sync_fd);

   if (ret != VK_SUCCESS)
      tu_DestroyFence(_device, *_fence, allocator);

   return ret;
}

VkResult
tu_GetSwapchainCounterEXT(VkDevice                    _device,
                          VkSwapchainKHR              swapchain,
                          VkSurfaceCounterFlagBitsEXT flag_bits,
                          uint64_t                    *value)
{
   TU_FROM_HANDLE(tu_device, device, _device);

   return wsi_get_swapchain_counter(_device,
                                    &device->physical_device->wsi_device,
                                    swapchain,
                                    flag_bits,
                                    value);
}