// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <fbl/auto_call.h>
#include <fbl/unique_fd.h>
#include <lib/fidl/coding.h>
#include <lib/fzl/fdio.h>
#include <lib/zx/vmo.h>
#include <zircon/assert.h>
#include <zircon/device/display-controller.h>
#include <zircon/pixelformat.h>
#include <zircon/process.h>
#include <zircon/syscalls.h>
#include <zircon/types.h>

#include "fuchsia/hardware/display/c/fidl.h"
#include "lib/framebuffer/framebuffer.h"

static zx_handle_t device_handle = ZX_HANDLE_INVALID;
static zx_handle_t dc_handle = ZX_HANDLE_INVALID;

static int32_t txid;
static uint64_t display_id;
static uint64_t layer_id;

static int32_t width;
static int32_t height;
static int32_t stride;
static zx_pixel_format_t format;
static bool type_set;
static uint32_t image_type;

static zx_handle_t vmo = ZX_HANDLE_INVALID;

static bool inited = false;
static bool in_single_buffer_mode;

static zx_status_t fb_import_image(zx_handle_t handle, uint32_t type, uint64_t* id_out);
static void fb_release_image(uint64_t id);

// Imports an event handle to use for image synchronization. This function
// always consumes |handle|. Id must be unique and not equal to FB_INVALID_ID.
static zx_status_t fb_import_event(zx_handle_t handle, uint64_t id);
static void fb_release_event(uint64_t id);

// Presents the image identified by |image_id|.
//
// If |wait_event_id| corresponds to an imported event, then driver will wait for
// for ZX_EVENT_SIGNALED before using the buffer. If |signal_event_id| corresponds
// to an imported event, then the driver will signal ZX_EVENT_SIGNALED when it is
// done with the image.
static zx_status_t fb_present_image(uint64_t image_id, uint64_t wait_event_id,
                                    uint64_t signal_event_id);

static zx_status_t set_layer_config(uint64_t layer_id, uint32_t width, uint32_t height,
                                    zx_pixel_format_t format, int32_t type) {
  fuchsia_hardware_display_ControllerSetLayerPrimaryConfigRequest layer_cfg_msg = {};
  layer_cfg_msg.hdr.ordinal = fuchsia_hardware_display_ControllerSetLayerPrimaryConfigOrdinal;
  layer_cfg_msg.layer_id = layer_id;
  layer_cfg_msg.image_config.width = width;
  layer_cfg_msg.image_config.height = height;
  layer_cfg_msg.image_config.pixel_format = format;
  layer_cfg_msg.image_config.type = type;

  return zx_channel_write(dc_handle, 0, &layer_cfg_msg, sizeof(layer_cfg_msg), NULL, 0);
}

zx_status_t fb_bind(bool single_buffer, const char** err_msg_out) {
  const char* err_msg;
  if (!err_msg_out) {
    err_msg_out = &err_msg;
  }
  *err_msg_out = "";

  if (inited) {
    *err_msg_out = "framebufer already initialzied";
    return ZX_ERR_ALREADY_BOUND;
  }

  // TODO(stevensd): Don't hardcode display controller 0
  fbl::unique_fd dc_fd(open("/dev/class/display-controller/000", O_RDWR));
  if (!dc_fd) {
    *err_msg_out = "Failed to open display controller";
    return ZX_ERR_NO_RESOURCES;
  }

  zx::channel device_server, device_client;
  zx_status_t status = zx::channel::create(0, &device_server, &device_client);
  if (status != ZX_OK) {
    *err_msg_out = "Failed to create device channel";
    return status;
  }

  zx::channel dc_server, dc_client;
  status = zx::channel::create(0, &dc_server, &dc_client);
  if (status != ZX_OK) {
    *err_msg_out = "Failed to create controller channel";
    return status;
  }

  fzl::FdioCaller caller(std::move(dc_fd));
  zx_status_t fidl_status = fuchsia_hardware_display_ProviderOpenController(
      caller.borrow_channel(), device_server.release(), dc_server.release(), &status);
  if (fidl_status != ZX_OK) {
    *err_msg_out = "Failed to call service handle";
    return fidl_status;
  }
  if (status != ZX_OK) {
    *err_msg_out = "Failed to open controller";
    return status;
  }

  device_handle = device_client.release();
  dc_handle = dc_client.release();
  fbl::AutoCall close_dc_handle([]() {
    zx_handle_close(device_handle);
    zx_handle_close(dc_handle);
    device_handle = ZX_HANDLE_INVALID;
    dc_handle = ZX_HANDLE_INVALID;
  });

  uint8_t bytes[ZX_CHANNEL_MAX_MSG_BYTES];
  uint32_t actual_bytes, actual_handles;
  bool has_display = false;
  do {
    zx_handle_t observed;
    uint32_t signals = ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED;
    if ((status = zx_object_wait_one(dc_handle, signals, ZX_TIME_INFINITE, &observed)) != ZX_OK) {
      *err_msg_out = "Failed waiting for display";
      return status;
    }
    if (observed & ZX_CHANNEL_PEER_CLOSED) {
      *err_msg_out = "Display controller connection closed";
      return ZX_ERR_PEER_CLOSED;
    }

    if ((status = zx_channel_read(dc_handle, 0, bytes, NULL, ZX_CHANNEL_MAX_MSG_BYTES, 0,
                                  &actual_bytes, &actual_handles)) != ZX_OK ||
        actual_bytes < sizeof(fidl_message_header_t)) {
      *err_msg_out = "Reading display addded callback failed";
      return status;
    }

    fidl_message_header_t* hdr = (fidl_message_header_t*)bytes;
    if (hdr->ordinal == fuchsia_hardware_display_ControllerDisplaysChangedOrdinal) {
      if ((status = fidl_decode(&fuchsia_hardware_display_ControllerDisplaysChangedEventTable,
                                bytes, actual_bytes, NULL, 0, err_msg_out)) != ZX_OK) {
        return status;
      }
      has_display = true;
    }
  } while (!has_display);

  // We're guaranteed that added contains at least one display, since we haven't
  // been notified of any displays to remove.
  fuchsia_hardware_display_ControllerDisplaysChangedEvent* changes =
      (fuchsia_hardware_display_ControllerDisplaysChangedEvent*)bytes;
  fuchsia_hardware_display_Info* display = (fuchsia_hardware_display_Info*)changes->added.data;
  fuchsia_hardware_display_Mode* mode = (fuchsia_hardware_display_Mode*)display->modes.data;
  zx_pixel_format_t pixel_format = ((int32_t*)(display->pixel_format.data))[0];

  fuchsia_hardware_display_ControllerComputeLinearImageStrideRequest stride_msg;
  stride_msg.hdr.ordinal = fuchsia_hardware_display_ControllerComputeLinearImageStrideOrdinal;
  stride_msg.hdr.txid = txid++;
  stride_msg.width = mode->horizontal_resolution;
  stride_msg.pixel_format = pixel_format;

  fuchsia_hardware_display_ControllerComputeLinearImageStrideResponse stride_rsp;
  zx_channel_call_args_t stride_call = {};
  stride_call.wr_bytes = &stride_msg;
  stride_call.rd_bytes = &stride_rsp;
  stride_call.wr_num_bytes = sizeof(stride_msg);
  stride_call.rd_num_bytes = sizeof(stride_rsp);
  if ((status = zx_channel_call(dc_handle, 0, ZX_TIME_INFINITE, &stride_call, &actual_bytes,
                                &actual_handles)) != ZX_OK) {
    *err_msg_out = "Failed to get linear stride";
    return status;
  }

  fuchsia_hardware_display_ControllerCreateLayerRequest create_layer_msg;
  create_layer_msg.hdr.ordinal = fuchsia_hardware_display_ControllerCreateLayerOrdinal;

  fuchsia_hardware_display_ControllerCreateLayerResponse create_layer_rsp;
  zx_channel_call_args_t call_args = {};
  call_args.wr_bytes = &create_layer_msg;
  call_args.rd_bytes = &create_layer_rsp;
  call_args.wr_num_bytes = sizeof(create_layer_msg);
  call_args.rd_num_bytes = sizeof(create_layer_rsp);
  if ((status = zx_channel_call(dc_handle, 0, ZX_TIME_INFINITE, &call_args, &actual_bytes,
                                &actual_handles)) != ZX_OK) {
    *err_msg_out = "Create layer call failed";
    return status;
  }
  if (create_layer_rsp.res != ZX_OK) {
    *err_msg_out = "Failed to create layer";
    status = create_layer_rsp.res;
    return status;
  }

  uint8_t fidl_bytes[sizeof(fuchsia_hardware_display_ControllerSetDisplayLayersRequest) +
                     FIDL_ALIGN(sizeof(uint64_t))];
  fuchsia_hardware_display_ControllerSetDisplayLayersRequest* set_display_layer_request =
      (fuchsia_hardware_display_ControllerSetDisplayLayersRequest*)fidl_bytes;
  *(uint64_t*)(fidl_bytes + sizeof(fuchsia_hardware_display_ControllerSetDisplayLayersRequest)) =
      create_layer_rsp.layer_id;

  set_display_layer_request->hdr.ordinal =
      fuchsia_hardware_display_ControllerSetDisplayLayersOrdinal;
  set_display_layer_request->display_id = display->id;
  set_display_layer_request->layer_ids.count = 1;
  set_display_layer_request->layer_ids.data = (void*)FIDL_ALLOC_PRESENT;

  if ((status = zx_channel_write(dc_handle, 0, fidl_bytes, sizeof(fidl_bytes), NULL, 0)) != ZX_OK) {
    *err_msg_out = "Failed to set display layers";
    return status;
  }

  if ((status = set_layer_config(create_layer_rsp.layer_id, mode->horizontal_resolution,
                                 mode->vertical_resolution, pixel_format, IMAGE_TYPE_SIMPLE)) !=
      ZX_OK) {
    *err_msg_out = "Failed to set layer config";
    return status;
  }

  display_id = display->id;
  layer_id = create_layer_rsp.layer_id;

  width = mode->horizontal_resolution;
  height = mode->vertical_resolution;
  format = pixel_format;
  stride = stride_rsp.stride;

  type_set = false;

  inited = true;

  fbl::AutoCall clear_inited([]() { inited = false; });

  zx::vmo local_vmo;

  if (single_buffer) {
    uint32_t size = stride * height * ZX_PIXEL_FORMAT_BYTES(format);
    fuchsia_hardware_display_ControllerAllocateVmoRequest alloc_msg;
    alloc_msg.hdr.ordinal = fuchsia_hardware_display_ControllerAllocateVmoOrdinal;
    alloc_msg.hdr.txid = txid++;
    alloc_msg.size = size;

    fuchsia_hardware_display_ControllerAllocateVmoResponse alloc_rsp;
    zx_channel_call_args_t call_args = {};
    call_args.wr_bytes = &alloc_msg;
    call_args.rd_bytes = &alloc_rsp;
    call_args.rd_handles = local_vmo.reset_and_get_address();
    call_args.wr_num_bytes = sizeof(alloc_msg);
    call_args.rd_num_bytes = sizeof(alloc_rsp);
    call_args.rd_num_handles = 1;
    uint32_t actual_bytes, actual_handles;
    if ((status = zx_channel_call(dc_handle, 0, ZX_TIME_INFINITE, &call_args, &actual_bytes,
                                  &actual_handles)) != ZX_OK) {
      *err_msg_out = "Failed vmo alloc call";
      return status;
    }
    if (alloc_rsp.res != ZX_OK) {
      status = alloc_rsp.res;
      *err_msg_out = "Failed to alloc vmo";
      return status;
    }

    // Failure to set the cache policy isn't a fatal error
    zx_vmo_set_cache_policy(local_vmo.get(), ZX_CACHE_POLICY_WRITE_COMBINING);

    zx_handle_t dup;
    if ((status = zx_handle_duplicate(local_vmo.get(), ZX_RIGHT_SAME_RIGHTS, &dup)) != ZX_OK) {
      *err_msg_out = "Couldn't duplicate vmo\n";
      return status;
    }

    // fb_(present|import)_image expect to not be in single buffer
    // mode, so make sure this is false for now. It will get set properly later.
    in_single_buffer_mode = false;

    uint64_t image_id;
    if ((status = fb_import_image(dup, 0, &image_id)) != ZX_OK) {
      *err_msg_out = "Couldn't import framebuffer";
      return status;
    }

    if ((status = fb_present_image(image_id, INVALID_ID, INVALID_ID)) != ZX_OK) {
      *err_msg_out = "Failed to present single_buffer mode framebuffer";
      return status;
    }
  }

  in_single_buffer_mode = single_buffer;

  clear_inited.cancel();
  vmo = local_vmo.release();
  close_dc_handle.cancel();

  return ZX_OK;
}

void fb_release() {
  if (!inited) {
    return;
  }

  zx_handle_close(device_handle);
  zx_handle_close(dc_handle);
  device_handle = ZX_HANDLE_INVALID;
  dc_handle = ZX_HANDLE_INVALID;

  if (in_single_buffer_mode) {
    zx_handle_close(vmo);
    vmo = ZX_HANDLE_INVALID;
  }

  inited = false;
}

void fb_get_config(uint32_t* width_out, uint32_t* height_out, uint32_t* linear_stride_px_out,
                   zx_pixel_format_t* format_out) {
  ZX_ASSERT(inited);

  *width_out = width;
  *height_out = height;
  *format_out = format;
  *linear_stride_px_out = stride;
}

zx_handle_t fb_get_single_buffer() {
  ZX_ASSERT(inited && in_single_buffer_mode);
  return vmo;
}

zx_status_t fb_import_image(zx_handle_t handle, uint32_t type, uint64_t* id_out) {
  ZX_ASSERT(inited && !in_single_buffer_mode);
  zx_status_t status;

  if (type_set && type != image_type) {
    return ZX_ERR_BAD_STATE;
  } else if (!type_set && type != IMAGE_TYPE_SIMPLE) {
    if ((status = set_layer_config(layer_id, width, height, format, type)) != ZX_OK) {
      return status;
    }
    image_type = type;
    type_set = true;
  }

  fuchsia_hardware_display_ControllerImportVmoImageRequest import_msg = {};
  import_msg.hdr.ordinal = fuchsia_hardware_display_ControllerImportVmoImageOrdinal;
  import_msg.hdr.txid = txid++;
  import_msg.image_config.height = height;
  import_msg.image_config.width = width;
  import_msg.image_config.pixel_format = format;
  import_msg.image_config.type = type;
  import_msg.vmo = FIDL_HANDLE_PRESENT;
  import_msg.offset = 0;

  fuchsia_hardware_display_ControllerImportVmoImageResponse import_rsp;
  zx_channel_call_args_t import_call = {};
  import_call.wr_bytes = &import_msg;
  import_call.wr_handles = &handle;
  import_call.rd_bytes = &import_rsp;
  import_call.wr_num_bytes = sizeof(import_msg);
  import_call.wr_num_handles = 1;
  import_call.rd_num_bytes = sizeof(import_rsp);
  uint32_t actual_bytes, actual_handles;
  if ((status = zx_channel_call(dc_handle, 0, ZX_TIME_INFINITE, &import_call, &actual_bytes,
                                &actual_handles)) != ZX_OK) {
    return status;
  }

  if (import_rsp.res != ZX_OK) {
    return import_rsp.res;
  }

  *id_out = import_rsp.image_id;
  return ZX_OK;
}

void fb_release_image(uint64_t image_id) {
  ZX_ASSERT(inited && !in_single_buffer_mode);

  fuchsia_hardware_display_ControllerReleaseEventRequest release_img_msg;
  release_img_msg.hdr.ordinal = fuchsia_hardware_display_ControllerReleaseEventOrdinal;
  release_img_msg.hdr.txid = txid++;
  release_img_msg.id = image_id;

  // There's nothing meaningful to do if this call fails
  zx_channel_write(dc_handle, 0, &release_img_msg, sizeof(release_img_msg), NULL, 0);
}

zx_status_t fb_import_event(zx_handle_t handle, uint64_t id) {
  ZX_ASSERT(inited && !in_single_buffer_mode);

  fuchsia_hardware_display_ControllerImportEventRequest import_evt_msg;
  import_evt_msg.hdr.ordinal = fuchsia_hardware_display_ControllerImportEventOrdinal;
  import_evt_msg.hdr.txid = txid++;
  import_evt_msg.id = id;
  import_evt_msg.event = FIDL_HANDLE_PRESENT;

  return zx_channel_write(dc_handle, 0, &import_evt_msg, sizeof(import_evt_msg), &handle, 1);
}

void fb_release_event(uint64_t id) {
  ZX_ASSERT(inited && !in_single_buffer_mode);

  fuchsia_hardware_display_ControllerReleaseEventRequest release_evt_msg;
  release_evt_msg.hdr.ordinal = fuchsia_hardware_display_ControllerReleaseEventOrdinal;
  release_evt_msg.hdr.txid = txid++;
  release_evt_msg.id = id;

  // There's nothing meaningful we can do if this call fails
  zx_channel_write(dc_handle, 0, &release_evt_msg, sizeof(release_evt_msg), NULL, 0);
}

zx_status_t fb_present_image(uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
  ZX_ASSERT(inited && !in_single_buffer_mode);
  zx_status_t status;

  fuchsia_hardware_display_ControllerSetLayerImageRequest set_msg;
  set_msg.hdr.ordinal = fuchsia_hardware_display_ControllerSetLayerImageOrdinal;
  set_msg.hdr.txid = txid++;
  set_msg.layer_id = layer_id;
  set_msg.image_id = image_id;
  set_msg.wait_event_id = wait_event_id;
  set_msg.signal_event_id = signal_event_id;
  if ((status = zx_channel_write(dc_handle, 0, &set_msg, sizeof(set_msg), NULL, 0)) != ZX_OK) {
    return status;
  }

  // It's not necessary to validate the configuration, since we're guaranteed that a single
  // fullscreen framebuffer on a single monitor will work.
  fuchsia_hardware_display_ControllerApplyConfigRequest apply_msg;
  apply_msg.hdr.txid = txid++;
  apply_msg.hdr.ordinal = fuchsia_hardware_display_ControllerApplyConfigOrdinal;
  return zx_channel_write(dc_handle, 0, &apply_msg, sizeof(apply_msg), NULL, 0);
}

zx_status_t fb_enable_vsync(bool enable) {
  fuchsia_hardware_display_ControllerEnableVsyncRequest enable_vsync;
  enable_vsync.hdr.ordinal = fuchsia_hardware_display_ControllerEnableVsyncOrdinal;
  enable_vsync.enable = enable;
  zx_status_t status;
  if ((status = zx_channel_write(dc_handle, 0, &enable_vsync, sizeof(enable_vsync), NULL, 0)) !=
      ZX_OK) {
    return status;
  }
  return ZX_OK;
}

zx_status_t fb_wait_for_vsync(zx_time_t* timestamp, uint64_t* image_id) {
  zx_status_t status;

  zx_handle_t observed;
  uint32_t signals = ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED;
  if ((status = zx_object_wait_one(dc_handle, signals, ZX_TIME_INFINITE, &observed)) != ZX_OK) {
    return status;
  }
  if (observed & ZX_CHANNEL_PEER_CLOSED) {
    return ZX_ERR_PEER_CLOSED;
  }

  uint8_t bytes[ZX_CHANNEL_MAX_MSG_BYTES];
  uint32_t actual_bytes, actual_handles;
  if ((status = zx_channel_read(dc_handle, 0, bytes, NULL, ZX_CHANNEL_MAX_MSG_BYTES, 0,
                                &actual_bytes, &actual_handles)) != ZX_OK) {
    return ZX_ERR_STOP;
  }

  if (actual_bytes < sizeof(fidl_message_header_t)) {
    return ZX_ERR_INTERNAL;
  }

  fidl_message_header_t* header = (fidl_message_header_t*)bytes;

  switch (header->ordinal) {
    case fuchsia_hardware_display_ControllerDisplaysChangedOrdinal:
      return ZX_ERR_STOP;
    case fuchsia_hardware_display_ControllerClientOwnershipChangeOrdinal:
      return ZX_ERR_NEXT;
    case fuchsia_hardware_display_ControllerVsyncOrdinal:
      break;
    default:
      return ZX_ERR_STOP;
  }

  const char* err_msg;
  if ((status = fidl_decode(&fuchsia_hardware_display_ControllerVsyncEventTable, bytes,
                            actual_bytes, NULL, 0, &err_msg)) != ZX_OK) {
    return ZX_ERR_STOP;
  }

  fuchsia_hardware_display_ControllerVsyncEvent* vsync =
      (fuchsia_hardware_display_ControllerVsyncEvent*)bytes;
  *timestamp = vsync->timestamp;
  *image_id = vsync->images.count ? *((uint64_t*)vsync->images.data) : FB_INVALID_ID;
  return ZX_OK;
}