/*
** Copyright (c) 2022 KikooDX
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to
** deal in the Software without restriction, including without limitation the
** rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
** sell copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
** IN THE SOFTWARE.
*/

#ifndef LZY_H_
#define LZY_H_
#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>

#ifdef FXCG50
#include <gint/keycodes.h>
typedef void LZY_Music;
typedef void LZY_Sound;
enum LZY_ScanCode {
	LZYK_LEFT = KEY_LEFT,
	LZYK_RIGHT = KEY_RIGHT,
	LZYK_UP = KEY_UP,
	LZYK_DOWN = KEY_DOWN,
	LZYK_O = KEY_SHIFT,
	LZYK_X = KEY_OPTN,
};
#else /* end FXCG50, begin SDL2 */
#ifndef LZY_SDL_MIXER_INCLUDE
#define LZY_SDL_MIXER_INCLUDE <SDL2/SDL_mixer.h>
#endif
#include LZY_SDL_MIXER_INCLUDE
enum LZY_ScanCode {
	LZYK_LEFT,
	LZYK_RIGHT,
	LZYK_UP,
	LZYK_DOWN,
	LZYK_O,
	LZYK_X,
	LZYK_COUNT,
};
typedef Mix_Music LZY_Music;
typedef Mix_Chunk LZY_Sound;
#endif /* SDL2 */

enum LZY_EventType {
	LZY_QUIT,
	LZY_KEYDOWN,
	LZY_KEYUP,
};

typedef struct LZY_KeyEvent {
	unsigned int scancode;
	int down;
} LZY_KeyEvent;

typedef union LZY_EventUnion {
	LZY_KeyEvent key;
} LZY_EventUnion;

typedef struct LZY_Event {
	int type;
	LZY_EventUnion u;
} LZY_Event;

int LZY_Init(const char *title, int target_fps,
                           const char *tset_path, const char *font_path);
void LZY_Quit(void);
int LZY_DrawBegin(void);
int LZY_DrawEnd(void);
void LZY_DrawSetColor(uint8_t r, uint8_t g, uint8_t b);
void LZY_DrawSetColorNone(void);
int LZY_DrawClear(void);
int LZY_DrawPoint(int x, int y);
int LZY_DrawLine(int x0, int y0, int x1, int y1);
int LZY_DrawRect(int x, int y, int w, int h);
int LZY_FillRect(int x, int y, int w, int h);
int LZY_DrawTile(unsigned int id, int x, int y);
int LZY_DrawTileEx(unsigned int id, int x, int y, unsigned int w,
                   unsigned int h);
int LZY_DrawChar(unsigned char chr, int x, int y);
int LZY_DrawText(int x, int y, const char *text);
int LZY_DrawTextF(int x, int y, const char *fmt, ...);
LZY_Music *LZY_MusicLoad(const char *path);
int LZY_MusicDestroy(LZY_Music *music);
int LZY_MusicPlay(LZY_Music *music, int loops);
LZY_Sound *LZY_SoundLoad(const char *path);
int LZY_SoundDestroy(LZY_Sound *sound);
void LZY_SoundSetVolume(LZY_Sound *sound, float volume);
int LZY_SoundPlay(LZY_Sound *sound, int loops);
int LZY_PollEvent(LZY_Event *);
void LZY_CycleEvents(void);
int LZY_KeyDown(unsigned int key);
int LZY_ShouldQuit(void);
void LZY_Log(const char *fmt, ...);
int LZY_LogError(int rv);
const char *LZY_GetError(void);

#ifdef __has_cpp_attribute
[[deprecated("renamed to LZY_FillRect")]]
#endif
int LZY_DrawFillRect(int x, int y, int w, int h);

#ifdef __cplusplus
}
#endif
#endif /* LZY_H_ */

/* implementation */
#ifdef LZY_IMPLEMENTATION
#undef LZY_IMPLEMENTATION
#ifndef LZY_SDL_INCLUDE
#define LZY_SDL_INCLUDE <SDL2/SDL.h>
#endif
#ifndef LZY_SDL_IMAGE_INCLUDE
#define LZY_SDL_IMAGE_INCLUDE <SDL2/SDL_image.h>
#endif
#ifndef LZY_SDL_MIXER_INCLUDE
#define LZY_SDL_MIXER_INCLUDE <SDL2/SDL_mixer.h>
#endif
#ifndef LZY_DISPLAY_WIDTH
#define LZY_DISPLAY_WIDTH 396
#endif
#ifndef LZY_DISPLAY_HEIGHT
#define LZY_DISPLAY_HEIGHT 224
#endif
#ifndef LZY_TILE_SIZE
#define LZY_TILE_SIZE 16
#endif
#ifndef LZY_CHR_WIDTH
#define LZY_CHR_WIDTH LZY_TILE_SIZE
#endif
#ifndef LZY_CHR_HEIGHT
#define LZY_CHR_HEIGHT LZY_TILE_SIZE
#endif
#ifndef LZY_FIRST_CHR
#define LZY_FIRST_CHR ' '
#endif
#include <stdio.h>

int LZY_DrawLine(int x0, int y0, int x1, int y1) {
	int dx, dy, sx, sy, err, e2;
	int rc = 0;

	dx = x1 - x0;
	dx = (dx < 0) ? (-dx) : (dx);
	dy = y1 - y0;
	dy = (dy < 0) ? (dy) : (-dy);
	sx = (x0 < x1) ? (1) : (-1);
	sy = (y0 < y1) ? (1) : (-1);
	err = dx + dy;

	for (;;) {
		if (LZY_DrawPoint(x0, y0))
			rc = -1;

		if (x0 == x1 && y0 == y1)
			break;

		e2 = 2 * err;
		if (e2 >= dy) {
			err += dy;
			x0 += sx;
		}
		if (e2 <= dx) {
			err += dx;
			y0 += sy;
		}
	}

	return rc;
}

int LZY_DrawTextF(int x, int y, const char *fmt, ...) {
	char buf[256] = {0};

	va_list args;
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf) - 1, fmt, args);
	va_end(args);

	return LZY_DrawText(x, y, buf);
}

int LZY_LogError(int rv) {
	LZY_Log("%s", LZY_GetError());

	return rv;
}

int LZY_DrawFillRect(int x, int y, int w, int h) {
	return LZY_FillRect(x, y, w, h);
}

#ifdef FXCG50
#include <gint/cpu.h>
#include <gint/display.h>
#include <gint/keyboard.h>
#include <gint/timer.h>
#include <stdint.h>

static const int draw_off_x = (DWIDTH - LZY_DISPLAY_WIDTH) / 2;
static const int draw_off_y = (DHEIGHT - LZY_DISPLAY_HEIGHT) / 2;
static color_t draw_color = C_BLACK;
static int should_quit = 0;
static int timer = 0;
static volatile int has_ticked = 0;
static unsigned int tset_width, tset_height;
static unsigned int font_width, font_height;
static int timer_callback(volatile int *);

static int _LZY_Sign(int n) {
	return (n > 0) - (n < 0);
}

int LZY_Init(const char *title, int target_fps, const char *tset_path,
             const char *font_path) {
	(void)title, (void)target_fps, (void)tset_path;

	extern bopti_image_t LZY_GINT_TILESET;
	extern bopti_image_t LZY_GINT_FONT;

	tset_width = LZY_GINT_TILESET.width / LZY_TILE_SIZE;
	tset_height = LZY_GINT_TILESET.height / LZY_TILE_SIZE;

	font_width = LZY_GINT_FONT.width / LZY_CHR_WIDTH;
	font_height = LZY_GINT_FONT.height / LZY_CHR_HEIGHT;

	if (target_fps > 0) {
		timer = timer_configure(TIMER_ANY, 1000000 / target_fps,
		                        GINT_CALL(timer_callback, &has_ticked));
		timer_start(timer);
	}

	return 0;
}

static int timer_callback(volatile int *arg) {
	*arg += 1;
	return 0;
}

void LZY_Quit(void) {
	if (timer) {
		timer_stop(timer);
		timer = 0;
	}
}

int LZY_DrawBegin(void) {
	return 0;
}

int LZY_DrawEnd(void) {
	dupdate();
	while (timer && !has_ticked)
		sleep();
	has_ticked = 0;
	return 0;
}

void LZY_DrawSetColor(uint8_t r, uint8_t g, uint8_t b) {
	draw_color = C_RGB(r / 8, g / 8, b / 8);
}

void LZY_DrawSetColorNone(void) {
	draw_color = C_NONE;
}

int LZY_DrawClear(void) {
	dclear(draw_color);
	return 0;
}

int LZY_DrawPoint(int x, int y) {
	dpixel(x + draw_off_x, y + draw_off_y, draw_color);
	return 0;
}

int LZY_DrawRect(int x, int y, int w, int h) {
	w += w == 0;
	h += h == 0;
	x += draw_off_x;
	y += draw_off_y;

	drect_border(x, y, x + w - _LZY_Sign(w), y + h - _LZY_Sign(h), C_NONE,
	             1, draw_color);
	return 0;
}

int LZY_FillRect(int x, int y, int w, int h) {
	w += w == 0;
	h += h == 0;
	x += draw_off_x;
	y += draw_off_y;

	drect(x, y, x + w - _LZY_Sign(w), y + h - _LZY_Sign(h), draw_color);
	return 0;
}

int LZY_DrawTile(unsigned int id, int x, int y) {
	extern bopti_image_t LZY_GINT_TILESET;
	int ix, iy;

	if (id >= tset_width * tset_height)
		return -1;
	x += draw_off_x;
	y += draw_off_y;

	ix = (id % tset_width) * LZY_TILE_SIZE;
	iy = (id / tset_width) * LZY_TILE_SIZE;
	dsubimage(x, y, &LZY_GINT_TILESET, ix, iy, LZY_TILE_SIZE, LZY_TILE_SIZE,
	          DIMAGE_NONE);

	return 0;
}

int LZY_DrawTileEx(unsigned int id, int x, int y, unsigned int w,
                   unsigned int h) {
	extern bopti_image_t LZY_GINT_TILESET;
	int ix, iy;

	if (w * h == 0)
		return -1;

	x += draw_off_x;
	y += draw_off_y;

	ix = id % tset_width;
	iy = id / tset_width;

	if (ix >= (int)tset_width || ix + w - 1 >= tset_width ||
	    iy >= (int)tset_height || iy + h - 1 >= tset_height)
		return -1;

	ix *= LZY_TILE_SIZE;
	iy *= LZY_TILE_SIZE;
	dsubimage(x, y, &LZY_GINT_TILESET, ix, iy, w * LZY_TILE_SIZE,
	          h * LZY_TILE_SIZE, DIMAGE_NONE);

	return 0;
}

int LZY_DrawChar(unsigned char chr, int x, int y) {
	extern bopti_image_t LZY_GINT_FONT;
	const unsigned int id = (unsigned int)chr - LZY_FIRST_CHR;
	int ix, iy;

	if (id >= font_width * font_height)
		return -1;
	x += draw_off_x;
	y += draw_off_y;

	ix = (id % font_width) * LZY_CHR_WIDTH;
	iy = (id / font_width) * LZY_CHR_HEIGHT;
	dsubimage(x, y, &LZY_GINT_FONT, ix, iy, LZY_CHR_WIDTH, LZY_CHR_HEIGHT,
	          DIMAGE_NONE);

	return 0;
}

int LZY_DrawText(int x, int y, const char *text) {
	int err = 0;

	if (text == NULL)
		return -1;

	for (; *text != '\0'; text++) {
		const int rc = LZY_DrawChar(*text, x, y);
		if (rc)
			err = rc - 1;
		x += LZY_CHR_WIDTH;
	}

	return err;
}

LZY_Music *LZY_MusicLoad(const char *path) {
	(void)path;
	return NULL;
}

int LZY_MusicDestroy(LZY_Music *music) {
	(void)music;
	return -1;
}

int LZY_MusicPlay(LZY_Music *music, int loops) {
	(void)music, (void)loops;
	return -1;
}

LZY_Sound *LZY_SoundLoad(const char *path) {
	(void)path;
	return NULL;
}

int LZY_SoundDestroy(LZY_Sound *sound) {
	(void)sound;
	return -1;
}

void LZY_SoundSetVolume(LZY_Sound *sound, float volume) {
	(void)sound, (void)volume;
}

int LZY_SoundPlay(LZY_Sound *sound, int loops) {
	(void)sound, (void)loops;
	return -1;
}

int LZY_PollEvent(LZY_Event *e) {
	for (;;) {
		const key_event_t gk_e = pollevent();

		switch (gk_e.type) {
		case KEYEV_NONE:
			return 0;
		case KEYEV_DOWN:
			e->type = LZY_KEYDOWN;
			e->u.key.scancode = gk_e.key;
			if (gk_e.key == KEY_EXIT)
				should_quit = 1;
			return 1;
		case KEYEV_UP:
			e->type = LZY_KEYUP;
			e->u.key.scancode = gk_e.key;
			return 1;
		default:
			break;
		}
	}
}

void LZY_CycleEvents(void) {
	clearevents();
	should_quit = should_quit || keydown(KEY_EXIT);
}

int LZY_KeyDown(unsigned int key) {
	return keydown(key);
}

int LZY_ShouldQuit(void) {
	return should_quit;
}

void LZY_Log(const char *fmt, ...) {
	(void)fmt;
}

const char *LZY_GetError(void) {
	return NULL;
}

#else /* end FXCG50, begin SDL2 */
#include LZY_SDL_INCLUDE
#include LZY_SDL_IMAGE_INCLUDE
#include LZY_SDL_MIXER_INCLUDE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static const SDL_Scancode sc[LZYK_COUNT * 2] = {
    SDL_SCANCODE_LEFT, SDL_SCANCODE_A, SDL_SCANCODE_RIGHT, SDL_SCANCODE_D,
    SDL_SCANCODE_UP,   SDL_SCANCODE_W, SDL_SCANCODE_DOWN,  SDL_SCANCODE_S,
    SDL_SCANCODE_Z,    SDL_SCANCODE_J, SDL_SCANCODE_X,     SDL_SCANCODE_K,
};
static const SDL_Scancode fullscreen_sc = SDL_SCANCODE_F11;
static const char *error = NULL;
static SDL_Window *window = NULL;
static SDL_Renderer *renderer = NULL;
static SDL_Texture *target = NULL;
static SDL_Texture *tset = NULL;
static SDL_Texture *font = NULL;
static int tset_width, tset_height, font_width, font_height;
static int should_quit = 0;
static int input[LZYK_COUNT] = {0};
static int fps_limiter = 0;
static uint64_t min_dt;
static uint64_t next_time;
static char *datadir;

static char *path_relative(const char *path) {
	char *buf;

	if (datadir == NULL) {
		error = "datadir is NULL";
		return NULL;
	}

	if (path == NULL) {
		error = "path is NULL";
		return NULL;
	}

	buf = calloc(strlen(datadir) + strlen(path) + 1, sizeof(char));
	if (buf == NULL) {
		error = "calloc failed";
		return NULL;
	}

	strcpy(buf, datadir);
	strcat(buf, path);

	return buf;
}

int LZY_Init(const char *title, int target_fps, const char *tset_path,
             const char *font_path) {
	const int img_flags = IMG_INIT_PNG;
	char *buf;

	datadir = SDL_GetBasePath();
	if (datadir == NULL) {
		error = SDL_GetError();
		return -1;
	}

	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
		error = SDL_GetError();
		return -1;
	}

	if ((IMG_Init(img_flags) & img_flags) != img_flags) {
		error = IMG_GetError();
		return -1;
	}

	if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0) {
		error = Mix_GetError();
		return -1;
	}

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0);

	window = SDL_CreateWindow(title, SDL_WINDOWPOS_UNDEFINED,
	                          SDL_WINDOWPOS_UNDEFINED, LZY_DISPLAY_WIDTH,
	                          LZY_DISPLAY_HEIGHT, SDL_WINDOW_RESIZABLE);
	if (window == NULL) {
		error = SDL_GetError();
		return -1;
	}

	SDL_SetWindowMinimumSize(window, LZY_DISPLAY_WIDTH, LZY_DISPLAY_HEIGHT);

	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
	if (renderer == NULL) {
		error = SDL_GetError();
		return -1;
	}

	target = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB888,
	                           SDL_TEXTUREACCESS_TARGET, LZY_DISPLAY_WIDTH,
	                           LZY_DISPLAY_HEIGHT);
	if (target == NULL) {
		error = SDL_GetError();
		return -1;
	}

	buf = path_relative(tset_path);
	if (buf == NULL)
		return -1;
	tset = IMG_LoadTexture(renderer, buf);
	if (tset == NULL) {
		error = IMG_GetError();
		return -1;
	}
	free(buf);

	if (SDL_QueryTexture(tset, NULL, NULL, &tset_width, &tset_height) < 0) {
		error = SDL_GetError();
		return -1;
	}
	tset_width /= LZY_TILE_SIZE;
	tset_height /= LZY_TILE_SIZE;

	buf = path_relative(font_path);
	if (buf == NULL)
		return -1;
	font = IMG_LoadTexture(renderer, buf);
	if (font == NULL) {
		error = IMG_GetError();
		return -1;
	}
	free(buf);

	if (SDL_QueryTexture(font, NULL, NULL, &font_width, &font_height) < 0) {
		error = SDL_GetError();
		return -1;
	}
	font_width /= LZY_CHR_WIDTH;
	font_height /= LZY_CHR_HEIGHT;

	fps_limiter = target_fps > 0;
	if (fps_limiter) {
		min_dt = 1000 / target_fps;
		next_time = SDL_GetTicks64();
	}

	return 0;
}

void LZY_Quit(void) {
	if (datadir != NULL) {
		SDL_free(datadir);
		datadir = NULL;
	}

	if (tset != NULL) {
		SDL_DestroyTexture(tset);
		tset = NULL;
	}

	if (target != NULL) {
		SDL_DestroyTexture(target);
		target = NULL;
	}

	if (renderer != NULL) {
		SDL_DestroyRenderer(renderer);
		renderer = NULL;
	}

	if (window != NULL) {
		SDL_DestroyWindow(window);
		window = NULL;
	}

	Mix_Quit();
	IMG_Quit();
	SDL_Quit();
}

int LZY_DrawBegin(void) {
	if (fps_limiter)
		next_time += min_dt;

	if (SDL_SetRenderTarget(renderer, target) < 0) {
		error = SDL_GetError();
		return -1;
	}
	return 0;
}

int LZY_DrawEnd(void) {
	int win_w, win_h, off_x, off_y;
	float ratio_w, ratio_h, scale;
	SDL_Rect src, dst;

	if (SDL_SetRenderTarget(renderer, NULL)) {
		error = SDL_GetError();
		return -1;
	}

	LZY_DrawSetColor(0x00, 0x00, 0x00);
	if (LZY_DrawClear())
		return -2;

	SDL_GetWindowSize(window, &win_w, &win_h);
	ratio_w = (float)win_w / LZY_DISPLAY_WIDTH;
	ratio_h = (float)win_h / LZY_DISPLAY_HEIGHT;
	scale = (ratio_w < ratio_h) ? (ratio_w) : (ratio_h);
	if (scale > 1.0)
		scale = (int)scale;
	off_x = (win_w - LZY_DISPLAY_WIDTH * scale) / 2;
	off_y = (win_h - LZY_DISPLAY_HEIGHT * scale) / 2;

	src.x = 0;
	src.y = 0;
	src.w = LZY_DISPLAY_WIDTH;
	src.h = LZY_DISPLAY_HEIGHT;

	dst.x = off_x;
	dst.y = off_y;
	dst.w = LZY_DISPLAY_WIDTH * scale;
	dst.h = LZY_DISPLAY_HEIGHT * scale;

	if (SDL_RenderCopy(renderer, target, &src, &dst) < 0) {
		error = SDL_GetError();
		return -3;
	}

	SDL_RenderPresent(renderer);

	if (fps_limiter) {
		const uint64_t cur_time = SDL_GetTicks64();
		if (next_time <= cur_time)
			next_time = cur_time;
		else
			SDL_Delay(next_time - cur_time);
	}
	return 0;
}

void LZY_DrawSetColor(uint8_t r, uint8_t g, uint8_t b) {
	SDL_SetRenderDrawColor(renderer, r, g, b, 0xff);
}

void LZY_DrawSetColorNone(void) {
	SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
}

int LZY_DrawClear(void) {
	if (SDL_RenderClear(renderer) < 0) {
		error = SDL_GetError();
		return -1;
	}
	return 0;
}

int LZY_DrawPoint(int x, int y) {
	if (SDL_RenderDrawPoint(renderer, x, y) < 0) {
		error = SDL_GetError();
		return -1;
	}
	return 0;
}

int LZY_DrawRect(int x, int y, int w, int h) {
	const SDL_Rect rect = {x, y, w + (w == 0), h + (h == 0)};

	if (SDL_RenderDrawRect(renderer, &rect) < 0) {
		error = SDL_GetError();
		return -2;
	}
	return 0;
}

int LZY_FillRect(int x, int y, int w, int h) {
	const SDL_Rect rect = {x, y, w + (w == 0), h + (h == 0)};

	if (SDL_RenderFillRect(renderer, &rect) < 0) {
		error = SDL_GetError();
		return -2;
	}
	return 0;
}

int LZY_DrawTile(unsigned int id, int x, int y) {
	SDL_Rect src, dst;

	if (id >= (unsigned int)(tset_width * tset_height)) {
		error = "id exceeds boundaries";
		return -1;
	}

	src.x = (id % tset_width) * LZY_TILE_SIZE;
	src.y = (id / tset_width) * LZY_TILE_SIZE;
	src.w = LZY_TILE_SIZE;
	src.h = LZY_TILE_SIZE;

	dst.x = x;
	dst.y = y;
	dst.w = LZY_TILE_SIZE;
	dst.h = LZY_TILE_SIZE;

	if (SDL_RenderCopy(renderer, tset, &src, &dst) < 0) {
		error = SDL_GetError();
		return -2;
	}

	return 0;
}

int LZY_DrawTileEx(unsigned int id, int x, int y, unsigned int w,
                   unsigned int h) {
	SDL_Rect src, dst;

	if (w * h == 0) {
		error = "tile size can't be 0";
		return -1;
	}

	if (id >= (unsigned int)(tset_width * tset_height)) {
		error = "id exceeds boundaries";
		return -1;
	}

	src.x = id % tset_width;
	src.y = id / tset_width;

	if (src.x >= tset_width || src.x + w - 1 >= (unsigned int)tset_width ||
	    src.y >= tset_height ||
	    src.y + h - 1 >= (unsigned int)tset_height) {
		error = "tile is not in tileset";
		return -1;
	}

	src.x *= LZY_TILE_SIZE;
	src.y *= LZY_TILE_SIZE;
	src.w = w * LZY_TILE_SIZE;
	src.h = h * LZY_TILE_SIZE;

	dst.x = x;
	dst.y = y;
	dst.w = w * LZY_TILE_SIZE;
	dst.h = h * LZY_TILE_SIZE;

	if (SDL_RenderCopy(renderer, tset, &src, &dst) < 0) {
		error = SDL_GetError();
		return -1;
	}

	return 0;
}

int LZY_DrawChar(unsigned char chr, int x, int y) {
	const unsigned int id = (unsigned int)chr - LZY_FIRST_CHR;
	SDL_Rect src, dst;

	if (id >= (unsigned int)(font_width * font_height)) {
		error = "chr exceeds boundaries";
		return -1;
	}

	src.x = (id % font_width) * LZY_CHR_WIDTH;
	src.y = (id / font_width) * LZY_CHR_HEIGHT;
	src.w = LZY_CHR_WIDTH;
	src.h = LZY_CHR_HEIGHT;

	dst.x = x;
	dst.y = y;
	dst.w = LZY_CHR_WIDTH;
	dst.h = LZY_CHR_HEIGHT;

	if (SDL_RenderCopy(renderer, font, &src, &dst) < 0) {
		error = SDL_GetError();
		return -2;
	}

	return 0;
}

int LZY_DrawText(int x, int y, const char *text) {
	int err = 0;

	if (text == NULL) {
		error = "text is NULL";
		return -1;
	}

	for (; *text != '\0'; text++) {
		const int rc = LZY_DrawChar(*text, x, y);
		if (rc)
			err = rc - 1;
		x += LZY_CHR_WIDTH;
	}

	return err;
}

LZY_Music *LZY_MusicLoad(const char *path) {
	char *buf;
	LZY_Music *music;

	buf = path_relative(path);
	if (buf == NULL)
		return NULL;
	music = Mix_LoadMUS(buf);
	if (music == NULL)
		error = Mix_GetError();
	free(buf);

	return music;
}

int LZY_MusicDestroy(LZY_Music *music) {
	if (music == NULL) {
		error = "music is NULL";
		return -1;
	}

	Mix_FreeMusic(music);
	return 0;
}

int LZY_MusicPlay(LZY_Music *music, int loops) {
	if (music == NULL) {
		error = "music is NULL";
		return -1;
	}

	if (Mix_PlayMusic(music, loops) < 0) {
		error = Mix_GetError();
		return -2;
	}
	return 0;
}

LZY_Sound *LZY_SoundLoad(const char *path) {
	char *buf;
	LZY_Sound *sound;

	buf = path_relative(path);
	if (buf == NULL)
		return NULL;
	sound = Mix_LoadWAV(buf);
	if (sound == NULL)
		error = Mix_GetError();
	free(buf);

	return sound;
}

int LZY_SoundDestroy(LZY_Sound *sound) {
	if (sound == NULL) {
		error = "sound is NULL";
		return -1;
	}

	Mix_FreeChunk(sound);
	return 0;
}

void LZY_SoundSetVolume(LZY_Sound *sound, float volume) {
	if (sound != NULL)
		Mix_VolumeChunk(sound, MIX_MAX_VOLUME * volume);
}

int LZY_SoundPlay(LZY_Sound *sound, int loops) {
	if (sound == NULL) {
		error = "sound is NULL";
		return -1;
	}

	if (Mix_PlayChannel(-1, sound, loops) < 0) {
		error = Mix_GetError();
		return -2;
	}

	return 0;
}

int LZY_PollEvent(LZY_Event *e) {
	SDL_Event sdl_e;

	while (SDL_PollEvent(&sdl_e) != 0) {
		switch (sdl_e.type) {
		case SDL_QUIT:
			e->type = LZY_QUIT;
			should_quit = 1;
			return 1;
		case SDL_KEYDOWN: {
			if (!sdl_e.key.repeat) {
				int i = LZYK_COUNT;
				while (i-- > 0) {
					if (sc[i * 2] ==
					        sdl_e.key.keysym.scancode ||
					    sc[i * 2 + 1] ==
					        sdl_e.key.keysym.scancode) {
						e->type = LZY_KEYDOWN;
						e->u.key.scancode = i;
						input[i] = 1;
						return 1;
					}
				}
				if (sdl_e.key.keysym.scancode ==
				    fullscreen_sc) {
					const unsigned int flag =
					    SDL_WINDOW_FULLSCREEN;
					const unsigned int fullscreen =
					    SDL_GetWindowFlags(window) & flag;
					SDL_SetWindowFullscreen(window,
					                        !fullscreen);
				}
			}
		} break;
		case SDL_KEYUP: {
			int i = LZYK_COUNT;
			while (i-- > 0) {
				if (sc[i * 2] == sdl_e.key.keysym.scancode ||
				    sc[i * 2 + 1] ==
				        sdl_e.key.keysym.scancode) {
					e->type = LZY_KEYUP;
					e->u.key.scancode = i;
					input[i] = 0;
					return 1;
				}
			}
		} break;
		default:
			break;
		}
	}

	return 0;
}

void LZY_CycleEvents(void) {
	LZY_Event e;

	while (LZY_PollEvent(&e) != 0)
		;
}

int LZY_KeyDown(unsigned int key) {
	if (key >= LZYK_COUNT)
		return 0;
	return input[key];
}

int LZY_ShouldQuit(void) {
	return should_quit;
}

void LZY_Log(const char *fmt, ...) {
	char buf[2048] = {0};
	va_list args;

	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf) - 1, fmt, args);
	va_end(args);

	SDL_Log("%s", buf);
}

const char *LZY_GetError(void) {
	return error;
}
#endif /* SDL2 */
#endif /* LZY_IMPLEMENTATION */