#include "devices.h"
#include <unistd.h>   
#include <string.h>   

i32 console_open(void *data, u32 mode) {
    USED(mode);
    USED(data);
    /* Nothing to open — stdin/stdout are always available */
    return 0;  /* Success */
}

i32 console_read(void *data, u8 *buffer, u32 size) {
    USED(data);
    ssize_t result = read(STDIN_FILENO, buffer, size);
    if (result < 0) return -1;  /* Error */
    return (i32)result;         /* Bytes read */
}

i32 console_write(void *data, const u8 *buffer, u32 size) {
    USED(data);
    ssize_t result = write(STDOUT_FILENO, buffer, size);
    if (result < 0) return -1;  /* Error */
    return (i32)result;         /* Bytes written */
}

i32 console_close(void *data) {
    USED(data);
    /* Nothing to close — stdin/stdout are process-owned */
    return 0;
}

i32 console_ioctl(void *data, u32 cmd, void *args) {
    USED(data);
    USED(cmd);
    USED(args);
    return -1; /* Unsupported */
}

i32 screen_open(void *data, u32 mode) {
  USED(mode);
  ScreenDeviceData *screen = (ScreenDeviceData *)data;


  screen->window =
      SDL_CreateWindow("Reality Engine VM", SDL_WINDOWPOS_CENTERED,
                       SDL_WINDOWPOS_CENTERED, screen->width, screen->height,
                       SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);

  if (!screen->window)
    return -1;

  screen->renderer = SDL_CreateRenderer(
      screen->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  if (!screen->renderer)
    return -1;

  screen->texture = SDL_CreateTexture(
      screen->renderer, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_STREAMING,
      screen->width, screen->height);
  if (!screen->texture)
    return -1;

  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");
  return 0;
}

i32 screen_read(void *data, u8 *buffer, u32 size) { 
  USED(data);
  USED(buffer);
  USED(size);
  return -1; 
}

i32 screen_write(void *data, const u8 *buffer, u32 size) {
  ScreenDeviceData *screen = (ScreenDeviceData *)data;

  if (size > screen->framebuffer_size * sizeof(u8)) {
    return -1;
  }

  memcpy(&screen->vm->memory[screen->framebuffer_pos], buffer, size);
  return 0;
}

i32 screen_close(void *data) {
  ScreenDeviceData *screen = (ScreenDeviceData *)data;

  if (screen->texture) {
    SDL_DestroyTexture(screen->texture);
    screen->texture = NULL;
  }
  if (screen->renderer) {
    SDL_DestroyRenderer(screen->renderer);
    screen->renderer = NULL;
  }
  if (screen->window) {
    SDL_DestroyWindow(screen->window);
    screen->window = NULL;
  }
  return 0;
}

/* MOUSE */
i32 mouse_open(void *data, u32 mode) { 
  USED(data);
  USED(mode);
  return 0; 
}

i32 mouse_read(void *data, u8 *buffer, u32 size) {
  MouseDeviceData *mouse = (MouseDeviceData *)data;

  if (size < 3 * sizeof(u32))
    return -1;

  u32 *out = (u32 *)buffer;
  out[0] = mouse->x;
  out[1] = mouse->y;
  out[2] = (mouse->btn1 | (mouse->btn2 << 1) | (mouse->btn3 << 2) |
            (mouse->btn4 << 3));
  return 0;
}

i32 mouse_write(void *data, const u8 *buffer, u32 size) { 
  USED(data);
  USED(buffer);
  USED(size);
  return -1; 
}

i32 mouse_close(void *data) { 
  USED(data);
  return 0; 
}

i32 keyboard_open(void *data, u32 mode) {
  USED(data);
  USED(mode);
  return 0; 
}

i32 keyboard_read(void *data, u8 *buffer, u32 size) {
  KeyboardDeviceData *kbd = (KeyboardDeviceData *)data;

  if (size < (u32)kbd->key_count)
    return -1;

  memcpy(buffer, kbd->keys, kbd->key_count);
  return 0;
}

i32 keyboard_write(void *data, const u8 *buffer, u32 size) {
  USED(data);
  USED(buffer);
  USED(size);
  return -1; /* not writable */
}

i32 keyboard_close(void *data) { 
  USED(data);
  return 0;
}