#include <SDL.h>
#include <SDL_keycode.h>
#include <assert.h>
#include "sdldefs.h"
#include "lispemul.h"
#include "lsptypes.h"
#include "miscstat.h"
#include "keyboard.h"
#include "lspglob.h" // for IOPage
#include "display.h" // for CURSORHEIGHT, DisplayRegion68k

#define  SDLRENDERING 1

static SDL_Window *sdl_window = NULL;
#if defined(SDLRENDERING)
static SDL_Renderer *sdl_renderer = NULL;
static SDL_RendererInfo sdl_rendererinfo = {0};
static SDL_Texture *sdl_texture = NULL;
#else
static SDL_Surface *sdl_windowsurface = NULL;
static SDL_Surface *sdl_buffersurface = NULL;
#endif
static Uint32 sdl_white;
static Uint32 sdl_black;
static Uint32 sdl_foreground;
static Uint32 sdl_background;
static int sdl_bytesperpixel;
static SDL_PixelFormat *sdl_pixelformat;
static int buffer_size = 0;
static void *buffer = NULL;

extern void kb_trans(u_short keycode, u_short upflg);
extern int error(const char *s);

extern int KBDEventFlg;
int keymap[] = {
  0, SDLK_5,
  1, SDLK_4,
  2, SDLK_6,
  3, SDLK_e,
  4, SDLK_7,
  5, SDLK_d,
  6, SDLK_u,
  7, SDLK_v,
  8, SDLK_RIGHTPAREN,
  8, SDLK_0,
  9, SDLK_k,
  10, SDLK_MINUS,
  11, SDLK_p,
  12, SDLK_SLASH,
  13, SDLK_KP_PERIOD,
  14, SDLK_SCROLLLOCK,
  15, SDLK_BACKSPACE,
  16, SDLK_3,
  17, SDLK_2,
  18, SDLK_w,
  19, SDLK_q,
  20, SDLK_s,
  21, SDLK_a,
  22, SDLK_LEFTPAREN,
  22, SDLK_9,
  23, SDLK_i,
  24, SDLK_x,
  25, SDLK_o,
  26, SDLK_l,
  27, SDLK_COMMA,
  28, SDLK_QUOTE,
  29, SDLK_RIGHTBRACKET,
  31, SDLK_LALT, /* Meta, Sun-4 usual key */
  32, SDLK_1,
  33, SDLK_ESCAPE,
  34, SDLK_TAB,
  35, SDLK_f,
  36, SDLK_LCTRL,
  37, SDLK_c,
  38, SDLK_j,
  39, SDLK_b,
  40, SDLK_z,
  41, SDLK_LSHIFT,
  42, SDLK_PERIOD,
  43, SDLK_SEMICOLON,
  43, SDLK_COLON,
  44, SDLK_RETURN,
  45, SDLK_BACKQUOTE,
  47, SDLK_RCTRL,
  48, SDLK_r,
  49, SDLK_t,
  50, SDLK_g,
  51, SDLK_y,
  52, SDLK_h,
  53, SDLK_8,
  54, SDLK_n,
  55, SDLK_m,
  56, SDLK_CAPSLOCK,
  57, SDLK_SPACE,
  58, SDLK_LEFTBRACKET,
  59, SDLK_EQUALS,
  60, SDLK_RSHIFT,
  61, SDLK_F11,
  61, SDLK_PAUSE,
  62, SDLK_HOME,
  63, SDLK_PAGEUP,
  64, SDLK_KP_EQUALS,
  65, SDLK_KP_DIVIDE,
  66, SDLK_F7,
  67, SDLK_F4,
  68, SDLK_F5,
  69, SDLK_KP_2,
  70, SDLK_KP_3,
  // 71, XK_Linefeed,
  // 73, XK_Numlock,
  76, SDLK_KP_ENTER,
  80, SDLK_F9,
  81, SDLK_KP_7,
  82, SDLK_KP_8,
  83, SDLK_KP_9,
  84, SDLK_KP_4,
  85, SDLK_KP_5,
  86, SDLK_LALT, /* (sun left-diamond key) */
  87, SDLK_KP_6,
  89, SDLK_INSERT,
  90, SDLK_END,
  91, SDLK_F12,
  92, SDLK_PRINTSCREEN, // is this XK_Print??
  93, SDLK_MODE, // is this XK_Mode_switch
  94, SDLK_KP_1,
  95, SDLK_KP_MULTIPLY,
  96, SDLK_KP_MINUS,
  97, SDLK_HELP,
  98, SDLK_KP_0,
  99, SDLK_F2,
  100, SDLK_F3,
  101, SDLK_F6,
  102, SDLK_KP_PLUS,
  104, SDLK_F8,
  105, SDLK_BACKSLASH,
  106, SDLK_F10,
  107, SDLK_F11,
  108, SDLK_F12,
  -1, -1
};
// all of the following are overwritten, the values here are irrelevant defaults!
// actual size of the lisp display in pixels.
int sdl_displaywidth = 0;
int sdl_displayheight = 0;
// current size of the window, in pixels
int sdl_windowwidth = 0;
int sdl_windowheight = 0;
// each pixel is shown as this many pixels
int sdl_pixelscale = 0;
extern DLword *EmKbdAd068K, *EmKbdAd168K, *EmKbdAd268K, *EmKbdAd368K, *EmKbdAd468K, *EmKbdAd568K,
  *EmRealUtilin68K;
extern DLword *CTopKeyevent;
extern int URaid_req;
extern LispPTR *KEYBUFFERING68k;

void DoRing() {
  DLword w, r;
  KBEVENT *kbevent;

 do_ring:
  /* DEL is not generally present on a Mac X keyboard, Ctrl-shift-ESC would be 18496 */
  if (((*EmKbdAd268K) & 2113) == 0) { /*Ctrl-shift-NEXT*/
    error("******  EMERGENCY Interrupt ******");
    *EmKbdAd268K = KB_ALLUP;          /*reset*/
    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
    /*return(0);*/
  } else if (((*EmKbdAd268K) & 2114) == 0) { /* Ctrl-Shift-DEL */
    *EmKbdAd268K = KB_ALLUP;                 /*reset*/
    URaid_req = T;
    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
    /*return(0);*/
  }

#ifdef OS4_TYPE4BUG
  else if (((*EmKbdAd268K) & 2120) == 0) { /* Ctrl-Shift-Return */
    *EmKbdAd268K = KB_ALLUP;               /*reset*/
    URaid_req = T;
    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
  }
#endif

  r = RING_READ(CTopKeyevent);
  w = RING_WRITE(CTopKeyevent);

  if (r == w) /* event queue FULL */
    goto KBnext;

  kbevent = (KBEVENT *)(CTopKeyevent + w);
  /*    RCLK(kbevent->time); */
  kbevent->W0 = *EmKbdAd068K;
  kbevent->W1 = *EmKbdAd168K;
  kbevent->W2 = *EmKbdAd268K;
  kbevent->W3 = *EmKbdAd368K;
  kbevent->W4 = *EmKbdAd468K;
  kbevent->W5 = *EmKbdAd568K;
  kbevent->WU = *EmRealUtilin68K;

  if (r == 0) /* Queue was empty */
    ((RING *)CTopKeyevent)->read = w;
  if (w >= MAXKEYEVENT)
    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
  else
    ((RING *)CTopKeyevent)->write = w + KEYEVENTSIZE;

 KBnext:
  if (*KEYBUFFERING68k == NIL) *KEYBUFFERING68k = ATOM_T;
}

static int min(int a, int b) {
  if(a < b)
    return a;
  return b;
}

static int should_update_texture = 0;

static int min_x = 0;
static int min_y = 0;
static int max_x = 0;
static int max_y = 0;
void sdl_notify_damage(int x, int y, int w, int h) {
  if(x < min_x)
    min_x = x;
  if(y < min_y)
    min_y = y;
  if(x + w > max_x)
    max_x = min(x + w, sdl_displaywidth - 1);
  if(y + h > max_y)
    max_y = min(y + h, sdl_displayheight - 1);
  should_update_texture = 1;
}

/* a simple linked list to remember generated cursors
 * because cursors don't have any identifying information
 * except for the actual bitmap in Lisp, just cache that.
 * 16 Uint16, to give a 16x16 bitmap cursor.
 */
struct CachedCursor {
  struct CachedCursor *next;
  DLword bitmap[CURSORHEIGHT];
  SDL_Cursor *cursor;
} *sdl_cursorlist = NULL;

static int cursor_equal_p(DLword *a, DLword *b) {
  for(int i = 0; i < CURSORHEIGHT; i++)
    if(a[i] != b[i]) return FALSE;
  return TRUE;
}

/*
 * Try to find cursor CURSOR on the sdl_cursorlist, if it isn't there, add it.
 * Return an SDL_Cursor that can be used directly.
 */
static SDL_Cursor *sdl_getOrAllocateCursor(Uint8 cursor[32], int hot_x, int hot_y) {
  hot_x = 0;
  hot_y = 0;
  int i = 0;
  /* try to find the cursor by checking the full bitmap */
  DLword *bitmap = (DLword*)cursor;
  struct CachedCursor *clp = sdl_cursorlist;
  for(; clp != NULL; clp = clp->next) {
    if(cursor_equal_p(clp->bitmap, bitmap) == TRUE) break;
  }
  if(clp == NULL) { /* it isn't there, push on a new one to the front of the list */
    clp = (struct CachedCursor *)malloc(sizeof(struct CachedCursor));
    for(int i = 0; i < CURSORHEIGHT; i++) clp->bitmap[i] = bitmap[i];
    SDL_Cursor *c = SDL_CreateCursor(cursor, cursor, 16, 16, hot_x, hot_y);
    if(c == NULL)
      printf("ERROR creating cursor: %s\n", SDL_GetError());
    clp->cursor = c;
    clp->next = sdl_cursorlist;
    sdl_cursorlist = clp;
    // printf("Creating new cursor, using it\n");
    return clp->cursor;
  } else {
    /* TODO: move to front of list */
    // printf("Found cursor, using it\n");
    return clp->cursor;
  }
}

/*
 * Read a cursor bitmap from lisp. Try to find a cached cursor, then use that.
 * Use HOT_X and HOT_Y as the cursor hotspot.
 */
void sdl_setCursor(int hot_x, int hot_y) {
  DLword *newbm = ((DLword *)(IOPage->dlcursorbitmap));
  Uint8 cursor[32];
  // printf("setCursor: bm %p, x %d, y %d\n", newbm, hot_x, hot_y);
  /* for(int i = 0; i < CURSORHEIGHT; i++) { */
  /*   printf("%04x ", newbm[i]); */
  /*   // cursor[i] = newbm[i % 2 == 1 ? i - 1 : i + 1]; */
  /* } */
  /* printf("\n"); */
  Uint8 *bitmap = (Uint8*)newbm;
  for (int i = 0; i < 32; i++) cursor[i] = bitmap[i ^ 3];
  // TODO: actually keep track of the cursors, don't just allocate a new one every time!
  /* for(int i = 0; i < CURSORHEIGHT * 2; i++) { */
  /*   printf("%02x ", cursor[i]); */
  /*   // cursor[i] = newbm[i % 2 == 1 ? i - 1 : i + 1]; */
  /* } */
  /* printf("\n"); */
  SDL_Cursor *c = sdl_getOrAllocateCursor(cursor, hot_x, hot_y);
  SDL_SetCursor(c);
}
#if defined(SDLRENDERING)
void sdl_bitblt_to_texture(int _x, int _y, int _w, int _h) {
  // printf("bitblt(%d, %d, %d, %d)\n", _x, _y, _w, _h);
  // Uint32 *dr = (Uint32 *)DisplayRegion68k;
  static const DLword mask[16] = {1<<15, 1<<14, 1<<13, 1<<12, 1<<11, 1<<10, 1<<9, 1<<8,
                                  1<<7, 1<<6, 1<<5, 1<<4, 1<<3, 1<<2, 1<<1, 1<<0};
  DLword *dr = DisplayRegion68k;
  void *destbuffer;
  int destpitchbytes;
  int destpitchpixels;
  // const int bitsperword = 8 * sizeof(Uint32);
  const int bitsperword = 8 * sizeof(DLword);
  int sourcepitchwords = sdl_displaywidth / bitsperword;
  int xstart = _x / bitsperword;
  int xlimit = (_x + _w + bitsperword - 1) / bitsperword;
  int ystart = _y * sourcepitchwords;
  int ylimit = (_y + _h) * sourcepitchwords;
  SDL_Rect destrect;
  /*  printf("_x %d _y %d _w %d _h %d; xstart %d xlimit %d ystart %d ylimit %d sourcepitchwords %d\n",
      _x, _y, _w, _h, xstart, xlimit, ystart, ylimit, sourcepitchwords); */
  // Avoid dealing with partial words in the update by stretching the source rectangle
  // left and right to cover complete units (32-bit words) and lock the corresponding
  // region in the texture
  destrect.x = (_x / bitsperword) * bitsperword;
  destrect.w = ((_x + _w + bitsperword - 1) / bitsperword * bitsperword) - destrect.x;
  destrect.y = _y;
  destrect.h = _h;
  SDL_LockTexture(sdl_texture, &destrect, &destbuffer, &destpitchbytes);
  destpitchpixels = destpitchbytes / sdl_bytesperpixel;
  int dy = 0;
  // for each line in the source image
  for(int sy = ystart; sy < ylimit ; sy += sourcepitchwords, dy += destpitchpixels) {
    // for each word in the line
    int dx = 0;
    for(int sx = xstart; sx < xlimit; sx++, dx += bitsperword) {
      int w = GETBASEWORD(dr, sy + sx);
      // for each bit in the word
      for(int b = 0; b < bitsperword; b++) {
        ((Uint32 *)destbuffer)[dy + dx + b] = (w & mask[b]) ? sdl_foreground : sdl_background;
      }
    }
  }
  SDL_UnlockTexture(sdl_texture);
}
#else
void sdl_bitblt_to_screen(int _x, int _y, int _w, int _h) {
  //  printf("bitblt(%d, %d, %d, %d)\n", _x, _y, _w, _h);
  Uint32 *dr = (Uint32*)DisplayRegion68k;

  int before = SDL_GetTicks();
  int width = sdl_displaywidth;
  int height = sdl_displayheight;
  int bpw = 8 * sizeof(Uint32);
  int pitch = sdl_displaywidth / bpw;
  int xlimit = (_x + _w + bpw - 1) / bpw;
  int ylimit = _y + _h;
  for(int y = _y; y < ylimit; y++) {
    int they = y * sdl_displaywidth;
    for(int x = _x / bpw; x < xlimit; x++) {
      int w = dr[y * pitch + x];
      int thex = x * bpw;
      for(int b = 0; b < bpw; b++) {
        //printf("%d/%d %d\n", x, y, b);
        uint32_t px = 0;
        if(w & (1 << (bpw - 1 - b))) {
          px = sdl_foreground;
        } else {
          px = sdl_background;
        }
        //printf("px is %x\n", px);
        int pxindex = they + thex + b;
        assert(pxindex >= 0 && pxindex < buffer_size);
        ((Uint32 *)buffer)[pxindex] = px;
      }
    }
  }
  int after = SDL_GetTicks();
  //  printf("bitblting took %dms\n", after - before);
}
void sdl_bitblt_to_window_surface(int _x, int _y, int _w, int _h) {
  //  printf("bitblt(%d, %d, %d, %d)\n", _x, _y, _w, _h);
  Uint32 *dr = (Uint32*)DisplayRegion68k;

  int before = SDL_GetTicks();
  int width = sdl_displaywidth;
  int height = sdl_displayheight;
  int bpw = 8 * sizeof(Uint32);
  int pitch = sdl_displaywidth / bpw;
  int xlimit = (_x + _w + bpw - 1) / bpw;
  int ylimit = _y + _h;
  for(int y = _y; y < ylimit; y++) {
    int they = y * sdl_displaywidth;
    for(int x = _x / bpw; x < xlimit; x++) {
      int w = dr[y * pitch + x];
      int thex = x * bpw;
      for(int b = 0; b < bpw; b++) {
        //printf("%d/%d %d\n", x, y, b);
        uint32_t px = 0;
        if(w & (1 << (bpw - 1 - b))) {
          px = sdl_foreground;
        } else {
          px = sdl_background;
        }
        //printf("px is %x\n", px);
        int pxindex = they + thex + b;
        assert(pxindex >= 0 && pxindex < buffer_size);
        ((Uint32 *)sdl_windowsurface->pixels)[pxindex] = px;
      }
    }
  }
  int after = SDL_GetTicks();
  //  printf("bitblting took %dms\n", after - before);
}
#endif
static int map_key(SDL_Keycode k) {
  for(int i = 0; keymap[i] != -1; i+= 2) {
    if(keymap[i+1] == k)
      return keymap[i];
  }
  return -1;
}
#define KEYCODE_OFFSET 0
static void handle_keydown(SDL_Keycode k, unsigned short mod) {
  int lk = map_key(k);
  if(lk == -1) {
    printf("No mapping for key %s\n", SDL_GetKeyName(k));
  } else {
    printf("dn %s -> lisp keycode %d (0x%x)\n", SDL_GetKeyName(k), lk, mod);
    kb_trans(lk - KEYCODE_OFFSET, FALSE);
    DoRing();
    if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
  }
}
static void handle_keyup(SDL_Keycode k, unsigned short mod) {
  int lk = map_key(k);
  if(lk == -1) {
    printf("No mapping for key %s\n", SDL_GetKeyName(k));
  } else {
    printf("up %s -> lisp keycode %d (0x%x)\n", SDL_GetKeyName(k), lk, mod);
    kb_trans(lk - KEYCODE_OFFSET, TRUE);
    DoRing();
    if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
  }
}
extern DLword *EmCursorX68K, *EmCursorY68K;
extern DLword *EmMouseX68K, *EmMouseY68K, *EmKbdAd068K, *EmRealUtilin68K;
extern LispPTR *CLastUserActionCell68k;
extern MISCSTATS *MiscStats;

/* bits within the EmRealUtilin word */
#define KEYSET_LEFT 8
#define KEYSET_LEFTMIDDLE 9
#define KEYSET_MIDDLE  10
#define KEYSET_RIGHTMIDDLE 11
#define KEYSET_RIGHT 12
/* Mouse buttons */
#define MOUSE_LEFT 13
#define MOUSE_RIGHT 14
#define MOUSE_MIDDLE 15
static void sdl_update_viewport(int width, int height) {
  /* XXX: needs work */
  int w = width / 32 * 32;
  if(w > sdl_displaywidth * sdl_pixelscale)
    w = sdl_displaywidth * sdl_pixelscale;
  int h = height / 32 * 32;
  if(h > sdl_displayheight * sdl_pixelscale)
    h = sdl_displayheight * sdl_pixelscale;
  SDL_Rect r;
  r.x = 0;
  r.y = 0;
  r.w = w;
  r.h = h;
#if defined(SDLRENDERING)
  SDL_RenderSetViewport(sdl_renderer, &r);
#endif
  printf("new viewport: %d / %d\n", w, h);
}
static int last_draw = 0;
static int last_keystate[512] = { 0 };
/* void handle_keyboard() { */
/*   SDL_PumpEvents(); */
/*   int numkeys; */
/*   const Uint8 *keystates = SDL_GetKeyboardState(&numkeys); */
/*   for(int i = 0; keymap[i] != -1; i+= 2) { */
/*     int keycode = keymap[i+1]; */
/*     int lk = keymap[i]; */
/*     int scancode = SDL_GetScancodeFromKey(keycode); */
/*     if(scancode < numkeys) { */
/*       int state = keystates[scancode]; */
/*       if(state != last_keystate[scancode]) { */
/*         printf("lk %d scancode %d %s <%s>\n", lk, scancode, state ? "pressed" : "released", SDL_GetKeyName(keycode)); */
/*         kb_trans(lk - KEYCODE_OFFSET, state ? FALSE : TRUE); */
/*         DoRing(); */
/*         if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0; */
/*       } */
/*       last_keystate[scancode] = state; */
/*     } */
/*   } */
/* } */
void sdl_set_invert(int flag) {
  if (flag) {
    sdl_foreground = sdl_white;
    sdl_background = sdl_black;
  } else {
    sdl_foreground = sdl_black;
    sdl_background = sdl_white;
  }
  sdl_notify_damage(0, 0, sdl_displaywidth, sdl_displayheight);
}
void sdl_setMousePosition(int x, int y) {
  SDL_WarpMouseInWindow(sdl_window, x * sdl_pixelscale, y * sdl_pixelscale);
}
#if defined(SDLRENDERING)
void sdl_update_display_rendering() {
  int before = 0;
  int after = 0;

  if(should_update_texture) {
    before = SDL_GetTicks();
    sdl_bitblt_to_texture(min_x, min_y, max_x - min_x, max_y - min_y);
    after = SDL_GetTicks();
    //    printf("UpdateTexture took %dms\n", after - before);
    should_update_texture = 0;
    min_x = sdl_displaywidth;
    min_y = sdl_displayheight;
    max_x = max_y = 0;
  }
  int this_draw = SDL_GetTicks();
  before = SDL_GetTicks();


  if(this_draw - last_draw > 10) {
    before = SDL_GetTicks();
    //SDL_RenderClear(sdl_renderer);
    SDL_Rect r;
    r.x = 0;
    r.y = 0;
    r.w = min(sdl_windowwidth / sdl_pixelscale, sdl_displaywidth);
    r.h = min(sdl_windowheight / sdl_pixelscale, sdl_displayheight);
    SDL_Rect s;
    s.x = 0;
    s.y = 0;
    s.w = min(sdl_windowwidth / sdl_pixelscale * sdl_pixelscale, sdl_displaywidth * sdl_pixelscale);
    s.h = min(sdl_windowheight / sdl_pixelscale * sdl_pixelscale, sdl_displayheight * sdl_pixelscale);
    SDL_RenderCopy(sdl_renderer, sdl_texture, &r, &s);
    //SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, NULL);
    SDL_RenderPresent(sdl_renderer);
    last_draw = this_draw;
    after = SDL_GetTicks();
    //    printf("rendering took %dms\n", after - before);
  }
}
#else
void sdl_update_display_surfaces() {
  int before = 0;
  int after = 0;
  int this_draw = SDL_GetTicks();

  /* check if there's anything to do and sufficient time has elapsed */
  if (!should_update_texture || this_draw - last_draw <= 16) {
    return;
  }
  SDL_Rect r;
  r.x = min_x;
  r.y = min_y;
  r.w = max_x - min_x;
  r.h = max_y - min_y;
  if (sdl_pixelscale == 1) {
    sdl_bitblt_to_window_surface(r.x, r.y, r.w, r.h);
    SDL_UpdateWindowSurfaceRects(sdl_window, &r, 1);
  } else {
    SDL_Rect s;
    s.x = r.x * sdl_pixelscale;
    s.y = r.y * sdl_pixelscale;
    s.w = r.w * sdl_pixelscale;
    s.h = r.h * sdl_pixelscale;
    sdl_bitblt_to_screen(r.x, r.y, r.w, r.h);
    SDL_BlitScaled(sdl_buffersurface, &r, sdl_windowsurface, &s);
    SDL_UpdateWindowSurfaceRects(sdl_window, &s, 1);
  }
  min_x = sdl_displaywidth;
  max_x = 0;
  min_y = sdl_displayheight;
  max_y = 0;
  should_update_texture = 0;
  after = SDL_GetTicks();
  last_draw = this_draw;
  //    printf("surface update took %dms\n", after - before);
}
#endif
int process_events_time = 0;
void process_SDLevents() {
  //  printf("processing events delta %dms\n", SDL_GetTicks() - process_events_time);
  process_events_time = SDL_GetTicks();
  SDL_Event event;
  while(SDL_PollEvent(&event)) {
    switch(event.type) {
    case SDL_QUIT:
      printf("quitting\n"); exit(0);
      break;
    case SDL_WINDOWEVENT:
      switch(event.window.event) {
      case SDL_WINDOWEVENT_RESIZED: {
        /* XXX: what about integer multiple of 32 requirements here? */
        sdl_windowwidth = event.window.data1;
        sdl_windowheight = event.window.data2;
        sdl_update_viewport(sdl_windowwidth, sdl_windowheight);
      }
        break;
      }
      break;
    case SDL_KEYDOWN:
      printf("dn ts: %x, type: %x, state: %x, repeat: %x, scancode: %x, sym: %x <%s>, mod: %x\n", event.key.timestamp, event.key.type, event.key.state, event.key.repeat, event.key.keysym.scancode, event.key.keysym.sym, SDL_GetKeyName(event.key.keysym.sym), event.key.keysym.mod);
      if (event.key.repeat) {
        /* Lisp needs to see the UP transition before the DOWN transition */
        handle_keyup(event.key.keysym.sym, event.key.keysym.mod);
      }
      handle_keydown(event.key.keysym.sym, event.key.keysym.mod);
      break;
    case SDL_KEYUP:
      printf("up ts: %x, type: %x, state: %x, repeat: %x, scancode: %x, sym: %x <%s>, mod: %x\n", event.key.timestamp, event.key.type, event.key.state, event.key.repeat, event.key.keysym.scancode, event.key.keysym.sym, SDL_GetKeyName(event.key.keysym.sym), event.key.keysym.mod);
      handle_keyup(event.key.keysym.sym, event.key.keysym.mod);
      break;
    case SDL_MOUSEMOTION: {
      int x, y;
      SDL_GetMouseState(&x, &y);
      x /= sdl_pixelscale;
      y /= sdl_pixelscale;
      *CLastUserActionCell68k = MiscStats->secondstmp;
      *EmCursorX68K = (*((DLword *)EmMouseX68K)) =
        (short)(x & 0xFFFF);
      *EmCursorY68K = (*((DLword *)EmMouseY68K)) =
        (short)(y & 0xFFFF);
      DoRing();
      if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
    }
      break;
    case SDL_MOUSEBUTTONDOWN: {
      int button = event.button.button;
      switch(button) {
      case 1: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_LEFT, FALSE); break;
      case 2: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_MIDDLE, FALSE); break;
      case 3: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_RIGHT, FALSE); break;
      case 4: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFT, FALSE); break;
      case 5: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFTMIDDLE, FALSE); break;
      case 6: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHT, FALSE); break;
      case 7: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHTMIDDLE, FALSE); break;
      }
      DoRing();
      if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
    }
      break;
    case SDL_MOUSEBUTTONUP: {
      int button = event.button.button;
      switch(button) {
      case 1: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_LEFT, TRUE); break;
      case 2: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_MIDDLE, TRUE); break;
      case 3: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_RIGHT, TRUE); break;
      case 4: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFT, TRUE); break;
      case 5: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFTMIDDLE, TRUE); break;
      case 6: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHT, TRUE); break;
      case 7: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHTMIDDLE, TRUE); break;
      }
      DoRing();
      if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
    }
      break;
    case SDL_MOUSEWHEEL:
      printf("mousewheel mouse %d x %d y %d direction %s\n", event.wheel.which, event.wheel.x, event.wheel.y, event.wheel.direction == SDL_MOUSEWHEEL_NORMAL ? "normal" : "flipped");
      break;
      /* case SDL_KEYMAPCHANGED: */
      /*   printf("SDL_KEYMAPCHANGED\n"); break; */
      /* case SDL_TEXTINPUT: */
      /*   printf("SDL_TEXTINPUT\n"); break; */
    default:
      printf("other event type: %d\n", event.type);
    }
  }
#if defined(SDLRENDERING)
  sdl_update_display_rendering();
#else
  sdl_update_display_surfaces();
#endif
}

int init_SDL(char *windowtitle, int w, int h, int s) {
  sdl_pixelscale = s;
  // width must be multiple of 32
  w = (w + 31) / 32 * 32;
  sdl_displaywidth = w;
  sdl_displayheight = h;
  sdl_windowwidth = w * s;
  sdl_windowheight = h * s;
  min_x = 0;
  max_x = sdl_displaywidth;
  min_y = 0;
  max_y = sdl_displayheight;
  int width = sdl_displaywidth;
  int height = sdl_displayheight;
  printf("requested width: %d, height: %d\n", width, height);
  if(SDL_Init(SDL_INIT_VIDEO) < 0) {
    printf("SDL could not be initialized. SDL_Error: %s\n", SDL_GetError());
    return 1;
  }
  printf("initialised\n");
  sdl_window = SDL_CreateWindow(windowtitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, sdl_windowwidth, sdl_windowheight, 0);
  printf("Window created\n");
  if(sdl_window == NULL) {
    printf("Window could not be created. SDL_Error: %s\n", SDL_GetError());
    return 2;
  }
#if defined(SDLRENDERING)
  printf("Creating renderer...\n");
  sdl_renderer = SDL_CreateRenderer(sdl_window, -1, SDL_RENDERER_ACCELERATED);
  if(NULL == sdl_renderer) {
    printf("SDL Error: %s\n", SDL_GetError());
    return 3;
  }
  SDL_SetRenderDrawColor(sdl_renderer, 127, 127, 127, 255);
  SDL_RenderClear(sdl_renderer);
  SDL_RenderPresent(sdl_renderer);
  SDL_GetRendererInfo(sdl_renderer, &sdl_rendererinfo);
  SDL_RenderSetScale(sdl_renderer, 1.0, 1.0);
  printf("Creating texture...\n");
  sdl_pixelformat = SDL_AllocFormat(sdl_rendererinfo.texture_formats[0]);
  sdl_texture = SDL_CreateTexture(sdl_renderer, sdl_pixelformat->format, SDL_TEXTUREACCESS_STREAMING, width, height);
  sdl_black = SDL_MapRGB(sdl_pixelformat, 0, 0, 0);
  sdl_white = SDL_MapRGB(sdl_pixelformat, 255, 255, 255);
  sdl_foreground = sdl_black;
  sdl_background = sdl_white;
  sdl_bytesperpixel = sdl_pixelformat->BytesPerPixel;
#else
  printf("Creating window surface and buffer surface\n");
  sdl_windowsurface = SDL_GetWindowSurface(sdl_window);
  sdl_pixelformat = sdl_windowsurface->format;
  sdl_black = SDL_MapRGB(sdl_pixelformat, 0, 0, 0);
  sdl_white = SDL_MapRGB(sdl_pixelformat, 255, 255, 255);
  sdl_foreground = sdl_black;
  sdl_background = sdl_white;
  sdl_bytesperpixel = sdl_pixelformat->BytesPerPixel;
  buffer_size = width * height * sdl_bytesperpixel;
  buffer = malloc(buffer_size);
  sdl_buffersurface = SDL_CreateRGBSurfaceWithFormatFrom(buffer, sdl_displaywidth, sdl_displayheight,
                                                         sdl_bytesperpixel * 8,
                                                         sdl_displaywidth * sdl_bytesperpixel,
                                                         sdl_pixelformat->format);
#endif
  printf("SDL initialised\n");
  return 0;
}