from sdl2 import *
import ctypes, atexit, numpy
from pc7_keys import *

window, rendered, surface, pixels = None, None, None, None
WIDTH, HEIGHT, SCALE = -1, -1, -1
pause_on_quit = False

def _PC_init(width=0, height=0, scale=1):
  global window, renderer, surface, pixels, WIDTH, HEIGHT, SCALE
  if SDL_Init(SDL_INIT_VIDEO) < 0: raise Exception("Failed to initialize SDL")
  dm = SDL_DisplayMode()
  SDL_GetCurrentDisplayMode(0, ctypes.byref(dm))
  if width <= 0: width = dm.w // SCALE
  if height <= 0: height = dm.h // SCALE
  WIDTH, HEIGHT, SCALE = width, height, scale
  window = SDL_CreateWindow("Polycalc SDL2".encode(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
    width * SCALE, height * SCALE, SDL_WINDOW_SHOWN)
  renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED)
  surface = SDL_CreateRGBSurface(0, width, height, 32, 0, 0, 0, 0)
  if None in [window, renderer, surface]: raise Exception("Failed to create SDL2 objects: " + SDL_GetError())
  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, b'0')
  SDL_SetRenderTarget(renderer, None)
  SDL_RenderSetScale(renderer, SCALE, SCALE)
  w, h = surface.contents.pitch // 4, surface.contents.h
  pxtype = ctypes.POINTER(ctypes.c_uint32 * (w*h))
  pxbuffer = ctypes.cast(surface.contents.pixels, pxtype)
  pixels = numpy.ctypeslib.as_array(pxbuffer.contents)
  atexit.register(polycalc_pc_quit)

def PC_clr():
  for i in range(WIDTH * HEIGHT): pixels[i] = 0xffffffff

def mkRGBA(color): return (color[0] << 16) + (color[1] << 8) + color[2]
def PC_spx(x, y, color):
  if x >= 0 and x < WIDTH and y >= 0 and y < HEIGHT: pixels[y*WIDTH + x] = mkRGBA(color)

def PC_show():
  global texture
  texture = SDL_CreateTextureFromSurface(renderer, surface)
  SDL_RenderCopy(renderer, texture, None, None)
  SDL_RenderPresent(renderer)
  SDL_DestroyTexture(texture)

def PC_sshot(scale=-1, fname=None):
  global renderer, texture
  if scale == -1: scale = SCALE
  w, h = WIDTH * scale, HEIGHT * scale
  if fname == None: fname = b"PC_sshot.bmp"
  fname = bytes(fname,'utf-8')
  surface = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0)
  SDL_SetRenderTarget(renderer, None)
  SDL_RenderSetScale(renderer, scale, scale)
  SDL_RenderReadPixels(renderer, None, 0, surface.contents.pixels, surface.contents.pitch)
  SDL_SaveBMP(surface, fname)
  SDL_SetRenderTarget(renderer, texture)
  SDL_RenderSetScale(renderer, 1, 1)

def PC_pause():
  event = SDL_Event()
  while 1:
    SDL_WaitEvent(event)
    if event.type == SDL_KEYDOWN: break
    if event.type == SDL_QUIT: raise SystemExit

def poly_fill_rect(x, y, w, h, color):
  SDL_SetRenderDrawColor(renderer, color[0], color[1], color[2], 255)
  SDL_RenderFillRect(renderer, SDL_Rect(x, y, w, h))

d_key = {
  K_0: (SDLK_KP_0, SDL_SCANCODE_KP_0), K_1: (SDLK_KP_1, SDL_SCANCODE_KP_1), K_2: (SDLK_KP_2, SDL_SCANCODE_KP_2),
  K_3: (SDLK_KP_3, SDL_SCANCODE_KP_3), K_4: (SDLK_KP_4, SDL_SCANCODE_KP_4), K_5: (SDLK_KP_5, SDL_SCANCODE_KP_5),
  K_6: (SDLK_KP_6, SDL_SCANCODE_KP_6), K_7: (SDLK_KP_7, SDL_SCANCODE_KP_7), K_8: (SDLK_KP_8, SDL_SCANCODE_KP_8),
  K_9: (SDLK_KP_9, SDL_SCANCODE_KP_9),
  K_F1: (SDLK_F1, SDL_SCANCODE_F1), K_F2: (SDLK_F2, SDL_SCANCODE_F2), K_F3: (SDLK_F3, SDL_SCANCODE_F3),
  K_F4: (SDLK_F4, SDL_SCANCODE_F4), K_F5: (SDLK_F5, SDL_SCANCODE_F5), K_F6: (SDLK_F6, SDL_SCANCODE_F6),
  K_LEFT: (SDLK_LEFT, SDL_SCANCODE_LEFT),
  K_UP: (SDLK_UP, SDL_SCANCODE_UP),
  K_DOWN: (SDLK_DOWN, SDL_SCANCODE_DOWN),
  K_RIGHT: (SDLK_RIGHT, SDL_SCANCODE_RIGHT),
  K_ENTER: (SDLK_RETURN, SDL_SCANCODE_RETURN),
  K_ENTER2: (SDLK_KP_ENTER, SDL_SCANCODE_KP_ENTER),
  K_ESC: (SDLK_ESCAPE, SDL_SCANCODE_ESCAPE),
  K_DEL: (SDLK_DELETE, SDL_SCANCODE_DELETE),
  K_DSEP: (SDLK_KP_COMMA, SDL_SCANCODE_KP_COMMA),
  K_ADD: (SDLK_KP_PLUS, SDL_SCANCODE_KP_PLUS),
  K_ADD2: (SDLK_PLUS, None),
  K_SUB: (SDLK_KP_MINUS, SDL_SCANCODE_KP_MINUS),
  K_SUB2: (SDLK_MINUS, SDL_SCANCODE_MINUS),
  K_MUL: (SDLK_KP_MULTIPLY, SDL_SCANCODE_KP_MULTIPLY),
  K_DIV: (SDLK_KP_DIVIDE, SDL_SCANCODE_KP_DIVIDE),
  K_SHIFT: (SDLK_LSHIFT, SDL_SCANCODE_LSHIFT),
  K_ALPHA: (SDLK_LALT, SDL_SCANCODE_LALT),
  K_LEFTP: (SDLK_LEFTPAREN, SDL_SCANCODE_5),
  K_RIGHTP: (SDLK_RIGHTPAREN, SDL_SCANCODE_MINUS),
}

def PC_wkey():
  event = SDL_Event()
  while 1:
    SDL_WaitEvent(event)
    if event.type == SDL_KEYDOWN:
      for key, value in d_key.items():
        if event.key.keysym.sym == value[0]: return key

def PC_tkey(key):
  st = SDL_GetKeyboardState(None)
  PC_clrevnts()
  return d_key[key][1] != None and st[d_key[key][1]] != 0 or False

def PC_click():
  x, y = ctypes.c_int(0), ctypes.c_int(0)
  st = SDL_GetMouseState(ctypes.byref(x), ctypes.byref(y))
  PC_clrevnts()
  if st & (
    SDL_BUTTON(SDL_BUTTON_LEFT) | SDL_BUTTON(SDL_BUTTON_RIGHT) | SDL_BUTTON(SDL_BUTTON_MIDDLE) | SDL_BUTTON(SDL_BUTTON_X1) |
    SDL_BUTTON(SDL_BUTTON_X2)
  ): return x.value // SCALE, y.value // SCALE
  return None

def PC_tesc(): return PC_tkey(K_ESC)

def PC_gkey():
  for key in d_key:
    if PC_tkey(key): return key
  return None

def PC_wnokey():
  t = 1
  while t:
    PC_clrevnts()
    t = 0
    for key in d_key:
      if PC_tkey(key): t = 1; break

def polycalc_pc_quit():
  PC_show()
  if pause_on_quit: PC_pause()
  SDL_FreeSurface(surface)
  SDL_DestroyRenderer(renderer)
  SDL_DestroyWindow(window)
  SDL_Quit()

def PC_clrevnts():
  event = SDL_Event()
  while SDL_PollEvent(ctypes.byref(event)): pass