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

#include <drm.h>
#include <drm_fourcc.h>
#include <errno.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

#include "bo.h"
#include "dev.h"
#include "modeset.h"

#if 0//def USE_ATOMIC_API
static uint32_t get_prop_id(struct sp_dev* dev,
                            drmModeObjectPropertiesPtr props, const char* name) {
  drmModePropertyPtr p;
  uint32_t i, prop_id = 0; /* Property ID should always be > 0 */

  for (i = 0; !prop_id && i < props->count_props; i++) {
    p = drmModeGetProperty(dev->fd, props->props[i]);
    if (!strcmp(p->name, name))
      prop_id = p->prop_id;
    drmModeFreeProperty(p);
  }
  if (!prop_id)
    printf("Could not find %s property\n", name);
  return prop_id;
}
#endif

int is_supported_format(struct sp_plane* plane, uint32_t format) {
  uint32_t i;

  for (i = 0; i < plane->plane->count_formats; i++) {
    if (plane->plane->formats[i] == format)
      return 1;
  }
  return 0;
}

static int get_supported_format(struct sp_plane* plane, uint32_t* format) {
  uint32_t i;

  for (i = 0; i < plane->plane->count_formats; i++) {
    if (plane->plane->formats[i] == DRM_FORMAT_XRGB8888 ||
        plane->plane->formats[i] == DRM_FORMAT_ARGB8888 ||
        plane->plane->formats[i] == DRM_FORMAT_RGBA8888) {
      *format = plane->plane->formats[i];
      return 0;
    }
  }
  printf("No suitable formats found!\n");
  return -ENOENT;
}

struct sp_dev* create_sp_dev(void) {
  struct sp_dev* dev;
  int ret, fd, i, j;
  drmModeRes* r = NULL;
  drmModePlaneRes* pr = NULL;

  fd = open("/dev/dri/card0", O_RDWR);
  if (fd < 0) {
    printf("failed to open card0\n");
    return NULL;
  }

  dev = (struct sp_dev*)calloc(1, sizeof(*dev));
  if (!dev) {
    printf("failed to allocate dev\n");
    return NULL;
  }

  dev->fd = fd;

#if 1
  ret = drmSetClientCap(dev->fd, DRM_CLIENT_CAP_ATOMIC, 1);
  if (ret) {
    printf("failed to set client cap atomic\n");
    goto err;
  }
  ret = drmSetClientCap(dev->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  if (ret) {
    printf("failed to set client cap\n");
    goto err;
  }
#endif

  r = drmModeGetResources(dev->fd);
  if (!r) {
    printf("failed to get r\n");
    goto err;
  }

  dev->num_connectors = r->count_connectors;
  dev->connectors = (drmModeConnectorPtr*)calloc(dev->num_connectors, sizeof(*dev->connectors));
  if (!dev->connectors) {
    printf("failed to allocate connectors\n");
    goto err;
  }
  for (i = 0; i < dev->num_connectors; i++) {
    dev->connectors[i] = drmModeGetConnector(dev->fd,
                                             r->connectors[i]);
    if (!dev->connectors[i]) {
      printf("failed to get connector %d\n", i);
      goto err;
    }
  }

  dev->num_encoders = r->count_encoders;
  dev->encoders = (drmModeEncoderPtr*)calloc(dev->num_encoders, sizeof(*dev->encoders));
  if (!dev->encoders) {
    printf("failed to allocate encoders\n");
    goto err;
  }
  for (i = 0; i < dev->num_encoders; i++) {
    dev->encoders[i] = drmModeGetEncoder(dev->fd, r->encoders[i]);
    if (!dev->encoders[i]) {
      printf("failed to get encoder %d\n", i);
      goto err;
    }
  }

  dev->num_crtcs = r->count_crtcs;
  dev->crtcs = (struct sp_crtc*)calloc(dev->num_crtcs, sizeof(struct sp_crtc));
  if (!dev->crtcs) {
    printf("failed to allocate crtcs\n");
    goto err;
  }
  for (i = 0; i < dev->num_crtcs; i++) {
    dev->crtcs[i].crtc = drmModeGetCrtc(dev->fd, r->crtcs[i]);
    if (!dev->crtcs[i].crtc) {
      printf("failed to get crtc %d\n", i);
      goto err;
    }
    dev->crtcs[i].scanout = NULL;
    dev->crtcs[i].pipe = i;
    dev->crtcs[i].num_planes = 0;
  }

  pr = drmModeGetPlaneResources(dev->fd);
  if (!pr) {
    printf("failed to get plane resources\n");
    goto err;
  }
  dev->num_planes = pr->count_planes;
  dev->planes = (struct sp_plane*)calloc(dev->num_planes, sizeof(struct sp_plane));
  for (i = 0; i < dev->num_planes; i++) {
    drmModeObjectPropertiesPtr props;
    struct sp_plane* plane = &dev->planes[i];

    plane->dev = dev;
    plane->plane = drmModeGetPlane(dev->fd, pr->planes[i]);
    if (!plane->plane) {
      printf("failed to get plane %d\n", i);
      goto err;
    }
    plane->bo = NULL;
    plane->in_use = 0;

    ret = get_supported_format(plane, &plane->format);
    if (ret) {
      printf("failed to get supported format: %d\n", ret);
      goto err;
    }

    for (j = 0; j < dev->num_crtcs; j++) {
      if (plane->plane->possible_crtcs & (1 << j))
        dev->crtcs[j].num_planes++;
    }

    props = drmModeObjectGetProperties(dev->fd, pr->planes[i],
                                       DRM_MODE_OBJECT_PLANE);
    if (!props) {
      printf("failed to get plane properties\n");
      goto err;
    }
#if 0//def USE_ATOMIC_API
    plane->crtc_pid = get_prop_id(dev, props, "CRTC_ID");
    if (!plane->crtc_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->fb_pid = get_prop_id(dev, props, "FB_ID");
    if (!plane->fb_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->crtc_x_pid = get_prop_id(dev, props, "CRTC_X");
    if (!plane->crtc_x_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->crtc_y_pid = get_prop_id(dev, props, "CRTC_Y");
    if (!plane->crtc_y_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->crtc_w_pid = get_prop_id(dev, props, "CRTC_W");
    if (!plane->crtc_w_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->crtc_h_pid = get_prop_id(dev, props, "CRTC_H");
    if (!plane->crtc_h_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->src_x_pid = get_prop_id(dev, props, "SRC_X");
    if (!plane->src_x_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->src_y_pid = get_prop_id(dev, props, "SRC_Y");
    if (!plane->src_y_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->src_w_pid = get_prop_id(dev, props, "SRC_W");
    if (!plane->src_w_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
    plane->src_h_pid = get_prop_id(dev, props, "SRC_H");
    if (!plane->src_h_pid) {
      drmModeFreeObjectProperties(props);
      goto err;
    }
#endif
    drmModeFreeObjectProperties(props);
  }

  if (pr)
    drmModeFreePlaneResources(pr);
  if (r)
    drmModeFreeResources(r);

  return dev;
err:
  if (pr)
    drmModeFreePlaneResources(pr);
  if (r)
    drmModeFreeResources(r);
  destroy_sp_dev(dev);
  return NULL;
}

void destroy_sp_dev(struct sp_dev* dev) {
  int i;

  if (dev->planes) {
    for (i = 0; i < dev->num_planes; i++) {
      if (dev->planes[i].in_use)
        put_sp_plane(&dev->planes[i]);
      if (dev->planes[i].plane)
        drmModeFreePlane(dev->planes[i].plane);
      if (dev->planes[i].bo)
        free_sp_bo(dev->planes[i].bo);
    }
    free(dev->planes);
  }
  if (dev->crtcs) {
    for (i = 0; i < dev->num_crtcs; i++) {
      if (dev->crtcs[i].crtc)
        drmModeFreeCrtc(dev->crtcs[i].crtc);
      if (dev->crtcs[i].scanout)
        free_sp_bo(dev->crtcs[i].scanout);
    }
    free(dev->crtcs);
  }
  if (dev->encoders) {
    for (i = 0; i < dev->num_encoders; i++) {
      if (dev->encoders[i])
        drmModeFreeEncoder(dev->encoders[i]);
    }
    free(dev->encoders);
  }
  if (dev->connectors) {
    for (i = 0; i < dev->num_connectors; i++) {
      if (dev->connectors[i])
        drmModeFreeConnector(dev->connectors[i]);
    }
    free(dev->connectors);
  }

  close(dev->fd);
  free(dev);
}