#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>

#include <stdio.h>
#include <unistd.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <poll.h>

/* TODO
 *
 * - utf-8 input
 * - arrow keys
 * - KEY_RESIZE or draw callback
 * - maybe some custom colors
 */

typedef enum {
	FG_BLACK     = 0,
	FG_RED       = 1,
	FG_GREEN     = 2,
	FG_YELLOW    = 3,
	FG_BLUE      = 4,
	FG_MAGENTA   = 5,
	FG_CYAN      = 6,
	FG_WHITE     = 7,

	FG_BBLACK    = FG_BLACK    + 8,
	FG_BRED      = FG_RED      + 8,
	FG_BGREEN    = FG_GREEN    + 8,
	FG_BYELLOW   = FG_YELLOW   + 8,
	FG_BBLUE     = FG_BLUE     + 8,
	FG_BMAGENTA  = FG_MAGENTA  + 8,
	FG_BCYAN     = FG_CYAN     + 8,
	FG_BWHITE    = FG_WHITE    + 8,

	BG_BLACK     = FG_BLACK    << 4,
	BG_RED       = FG_RED      << 4,
	BG_GREEN     = FG_GREEN    << 4,
	BG_YELLOW    = FG_YELLOW   << 4,
	BG_BLUE      = FG_BLUE     << 4,
	BG_MAGENTA   = FG_MAGENTA  << 4,
	BG_CYAN      = FG_CYAN     << 4,
	BG_WHITE     = FG_WHITE    << 4,

	BG_BBLACK    = FG_BBLACK   << 4,
	BG_BRED      = FG_BRED     << 4,
	BG_BGREEN    = FG_BGREEN   << 4,
	BG_BYELLOW   = FG_BYELLOW  << 4,
	BG_BBLUE     = FG_BBLUE    << 4,
	BG_BMAGENTA  = FG_BMAGENTA << 4,
	BG_BCYAN     = FG_BCYAN    << 4,
	BG_BWHITE    = FG_BWHITE   << 4,

	A_BOLD       = 1 << 8,
	A_DIM        = 1 << 9,
	A_ITALIC     = 1 << 10,
	A_UNDERSCORE = 1 << 11,
	A_BLINK      = 1 << 12,
	A_REVERSE    = 1 << 13,
} VuiAttr;

#define ATTR_FG(a) ((a) & 0xf)
#define ATTR_BG(a) (((a)>>4) & 0xf)
#define ATTR_A(a) ((a) & ~0xff)
#define ATTR_DEFAULT (FG_WHITE | BG_BLACK)

typedef struct {
	unsigned width, height;
	char *chr;
	uint16_t *attr;
} VuiBuffer;

typedef struct {
	unsigned width, height;
	VuiBuffer buf1, buf2;
	VuiBuffer *front, *back;
	int redraw_all;
} VuiWindow;

static struct termios vui_init_stdin_tos, vui_init_stdout_tos, vui_raw_stdin_tos, vui_raw_stdout_tos;
VuiWindow vui_win = {
	.front = &vui_win.buf1,
	.back = &vui_win.buf2,
};

#define BCHR(b,x,y)  ((b)->chr[(x) + (y) * (b)->width])
#define BATTR(b,x,y) ((b)->attr[(x) + (y) * (b)->width])
#define CHR(x,y)  BCHR(vui_win.front, x, y)
#define ATTR(x,y) BATTR(vui_win.front, x, y)

void vui_getwinsz(unsigned *w, unsigned *h) {
	struct winsize wsz;
	ioctl(STDOUT_FILENO, TIOCGWINSZ, &wsz);
	*w = wsz.ws_col;
	*h = wsz.ws_row;
}

static void vui_clrspan(VuiBuffer *buf, unsigned x0, unsigned x1, unsigned y) {
	for (unsigned x = x0; x < x1; x++) {
		BCHR(buf, x, y) = ' ';
	}
	for (unsigned x = x0; x < x1; x++) {
		BATTR(buf, x, y) = ATTR_DEFAULT;
	}
}

static void vui_clrtoeol(VuiBuffer *buf, unsigned x0, unsigned y) {
	vui_clrspan(buf, x0, buf->width, y);
}

static void clear_buf(VuiBuffer *buf) {
	for (unsigned y = 0; y < buf->height; y++) {
		vui_clrtoeol(buf, 0, y);
	}
}

static void vui_clear(void) {
	clear_buf(vui_win.front);
}

static void resize_buf(VuiBuffer *buf, unsigned nw, unsigned nh) {
	char *nchr      = calloc(nw * nh, sizeof(*buf->chr));
	uint16_t *nattr = calloc(nw * nh, sizeof(*buf->attr));
	assert(nchr);
	assert(nattr);

	unsigned oldw = buf->width;
	unsigned oldh = buf->height;
	unsigned minw = nw < oldw ? nw : oldw;
	unsigned minh = nh < oldh ? nh : oldh;
	for (unsigned y = 0; y < minh; y++) {
		memcpy(nchr  + y*nw, buf->chr  + y*oldw, minw * sizeof(*buf->chr));
		memcpy(nattr + y*nw, buf->attr + y*oldw, minw * sizeof(*buf->attr));
	}

	free(buf->chr);
	free(buf->attr);
	buf->chr = nchr;
	buf->attr = nattr;
	buf->width = nw;
	buf->height = nh;
	for (unsigned y = 0; y < minh; y++) vui_clrtoeol(buf, minw, y);
	for (unsigned y = minh; y < buf->height; y++) vui_clrtoeol(buf, 0, y);
}

static void vui_resize(unsigned nw, unsigned nh) {
	resize_buf(&vui_win.buf1, nw, nh);
	resize_buf(&vui_win.buf2, nw, nh);
	vui_win.width = nw;
	vui_win.height = nh;
}

static void vui_adjust(void) {
	unsigned w, h;
	vui_getwinsz(&w, &h);
	if (w != vui_win.width || h != vui_win.height) {
		vui_resize(w, h);
		vui_win.redraw_all = 1;
	}
}

void vui_curs_vis(int vis) {
	if (vis) {
		fputs("\x1b[?25h", stdout);
	} else {
		fputs("\x1b[?25l", stdout);
	}
}

void vui_init(void) {
	tcgetattr(STDIN_FILENO, &vui_init_stdin_tos);
	vui_raw_stdin_tos = vui_init_stdin_tos;
	vui_raw_stdin_tos.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
	tcsetattr(STDIN_FILENO, TCSANOW, &vui_raw_stdin_tos);

	tcgetattr(STDOUT_FILENO, &vui_init_stdout_tos);
	vui_raw_stdout_tos = vui_init_stdout_tos;
	vui_raw_stdout_tos.c_oflag &= ~OPOST;
	tcsetattr(STDOUT_FILENO, TCSANOW, &vui_raw_stdout_tos);

	vui_adjust();
}


static void free_buf(VuiBuffer *buf) {
	free(buf->chr);
	free(buf->attr);
	buf->chr = NULL;
	buf->attr = NULL;
	buf->width = 0;
	buf->height = 0;
}

void vui_fini(void) {
	tcsetattr(STDIN_FILENO, TCSANOW, &vui_init_stdin_tos);
	tcsetattr(STDOUT_FILENO, TCSANOW, &vui_init_stdout_tos);
	vui_curs_vis(1);
	free_buf(&vui_win.buf1);
	free_buf(&vui_win.buf2);
	printf("\x1b[H\x1b[2J\x1b[0m");
}

static inline int bchr_equiv(VuiBuffer *back, VuiBuffer *front, int x, int y) {
	return BCHR(back,x,y) == BCHR(front,x,y)
		&& (BATTR(back,x,y) == BATTR(front,x,y)
				/* || BCHR(back,x,y) == ' ' */);
}

static inline void curs_move(int src_x, int src_y, int dst_x, int dst_y) {
	if (src_x != dst_x && src_y != dst_y) {
		if (dst_x > 0) {
			printf("\x1b[%d;%dH", dst_y + 1, dst_x + 1);
		} else {
			printf("\x1b[%dH", dst_y + 1);
		}
	} else if (src_x != dst_x) {
		printf("\x1b[%dG", dst_x + 1);
	} else if (src_y != dst_y) {
		printf("\x1b[%dd", dst_y + 1);
	}
}

static void attr_chg(VuiAttr *ptr, VuiAttr to) {
	VuiAttr from = *ptr;
	if (from == to) return;
	char buf[64] = { 0 };
	char *s = buf;

	int chg_attr = (ATTR_A(from) != ATTR_A(to));
	chg_attr = 0;

	if (chg_attr) {
		*s++ = '\x1b';
		*s++ = '[';
		*s++ = '0';
		if (to & A_BOLD) *s++ = ';', *s++ = '1';
		if (to & A_DIM) *s++ = ';', *s++ = '1';
		if (to & A_ITALIC) *s++ = ';', *s++ = '3';
		if (to & A_UNDERSCORE) *s++ = ';', *s++ = '4';
		if (to & A_BLINK) *s++ = ';', *s++ = '5';
		if (to & A_REVERSE) *s++ = ';', *s++ = '7';
		from = ATTR_DEFAULT;
		assert(ATTR_FG(from) == FG_WHITE);
		assert(ATTR_BG(from) == BG_BLACK);
	}

	int f_fg = ATTR_FG(from);
	int f_bg = ATTR_BG(from);
	int t_fg = ATTR_FG(to);
	int t_bg = ATTR_BG(to);

	int chg_fg = (t_fg != f_fg);
	int chg_bg = (t_bg != f_bg);
	if (chg_fg || chg_bg) {
		if (chg_attr) *s++ = ';';
		else *s++ = '\x1b', *s++ = '[';
		if (chg_fg) {
			*s++ = (t_fg > 7 ? '9' : '3');
			*s++ = (t_fg & 7) + '0';
		}
		if (chg_bg) {
			if (chg_fg) *s++ = ';';
			if (t_bg > 7) {
				*s++ = '1';
				*s++ = '0';
			} else {
				*s++ = '4';
			}
			*s++ = (t_bg & 7) + '0';
		}
	}

	if (chg_fg || chg_bg || chg_attr) {
		*s++ = 'm';
		fwrite(buf, 1, s - buf, stdout);
	}

	*ptr = to;
}

unsigned vui_changes = 0;
unsigned vui_max_change = 0;
unsigned vui_repainted = 0;
void vui_blit(void) {
	VuiBuffer *front = vui_win.front;
	VuiBuffer *back = vui_win.back;

	printf("\x1b[H\x1b[0m");
	VuiAttr attr_last = ATTR_DEFAULT;

	if (vui_win.redraw_all) {
		vui_changes = vui_win.width * vui_win.height;
		for (unsigned y = 0; y < vui_win.height; y++) {
			for (unsigned x = 0; x < vui_win.width; x++) {
				attr_chg(&attr_last, ATTR(x, y));
				putchar(CHR(x, y));
			}
		}
		vui_repainted = vui_win.width * vui_win.height;
		vui_win.redraw_all = 0;
		goto copy_buf;
	}

	vui_changes = 0;
	vui_max_change = 0;
	vui_repainted = 0;
	unsigned cur_x = 0, cur_y = 0;
	for (unsigned y = 0; y < vui_win.height; y++) {
		unsigned x = 0;
		while (x < vui_win.width) {
			while (x < vui_win.width && bchr_equiv(back, front, x, y)) x++;
			if (x >= vui_win.width) break;
			unsigned x0 = x;
			VuiAttr a = ATTR(x0, y);
			while (x < vui_win.width && !bchr_equiv(back, front, x, y) && ATTR(x, y) == a) x++;
			if (x0 != x) {
				vui_changes++;
				curs_move(cur_x, cur_y, x0, y);
				attr_chg(&attr_last, a);
				fwrite(&CHR(x0, y), 1, x - x0, stdout);
				//printf("%.*s", x - x0, );
				cur_x = x;
				cur_y = y;
				vui_repainted += x - x0;
				if (x - x0 > vui_max_change) vui_max_change = x - x0;
			}
		}
	}

copy_buf:
	fflush(stdout);
	memcpy(back->chr,  front->chr,  sizeof(*back->chr)  * (back->width * back->height));
	memcpy(back->attr, front->attr, sizeof(*back->attr) * (back->width * back->height));
	vui_win.front = back;
	vui_win.back = front;
}

void vui_chra(int x, int y, char c, VuiAttr a) {
	if (x >= 0 && x < (int)vui_win.width && y >= 0 && y < (int)vui_win.height) {
		CHR(x, y) = c;
		ATTR(x, y) = a;
	}
}

void vui_chr(int x, int y, char c) {
	vui_chra(x, y, c, ATTR_DEFAULT);
}

int vui_avprintf(int x, int y, VuiAttr a, const char *fmt, va_list ap) {
	va_list ap2;
	va_copy(ap2, ap);
	int n = vsnprintf(NULL, 0, fmt, ap);
	if (x < 0) x = vui_win.width + x - (n - 1);
	if (y < 0) y = vui_win.height + y;
	if (n > 0) {
		char buf[n + 1];
		vsnprintf(buf, n + 1, fmt, ap2);
		memcpy(&CHR(x,y), buf, n < vui_win.width - x ? n : vui_win.width - x);
		for (unsigned x1 = x; x1 < vui_win.width && x1 < x + n; x1++) {
			ATTR(x1, y) = a;
		}
	}
	return n;
}

int vui_aprintf(int x, int y, VuiAttr a, const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int r = vui_avprintf(x, y, a, fmt, ap);
	va_end(ap);
	return r;
}

int vui_printf(int x, int y, const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int r = vui_avprintf(x, y, ATTR_DEFAULT, fmt, ap);
	va_end(ap);
	return r;
}

void on_sigwinch(int _) {
	vui_adjust();
	vui_blit();
}

int wait_for_input(int fd, int ms) {
	return poll(&(struct pollfd) { .fd = fd, .events = POLLIN }, 1, ms);
}

unsigned isqrt(unsigned x) {
        if (x <= 1) return x;
        unsigned a = x/2, b = (a + x/a) / 2;
        while (b < a) a = b, b = (a + x/a) / 2;
        return a;
}

void vui_scroll_buf(VuiBuffer *b, int dx, int dy) {
	if (abs(dx) >= b->width || abs(dy) >= b->height) {
		clear_buf(b);
		return;
	}
	if (dy > 0) {
		memmove(b->chr  + (b->width * dy), b->chr,  sizeof(*b->chr)  * b->width * (b->height - dy));
		memmove(b->attr + (b->width * dy), b->attr, sizeof(*b->attr) * b->width * (b->height - dy));
		for (int y = 0; y < dy; y++) vui_clrtoeol(b, 0, y);
	} else if (dy < 0) {
		memmove(b->chr,  b->chr  + (b->width * -dy), sizeof(*b->chr)  * b->width * (b->height + dy));
		memmove(b->attr, b->attr + (b->width * -dy), sizeof(*b->attr) * b->width * (b->height + dy));
		for (int y = b->height - 1; y > b->height + dy - 1; y--) vui_clrtoeol(b, 0, y);
	}
	if (dx > 0) {
		for (unsigned i = 0; i < b->height; i++) {
			memmove(b->chr + (i * b->width) + dx, b->chr + (i * b->width), sizeof(*b->chr) * (b->width - dx));
		}
		for (unsigned i = 0; i < b->height; i++) {
			memmove(b->attr + (i * b->width) + dx, b->attr + (i * b->width), sizeof(*b->attr) * (b->width - dx));
		}
		for (unsigned i = 0; i < b->height; i++) {
			vui_clrspan(b, 0, dx, i);
		}
	} else if (dx < 0) {
		for (unsigned i = 0; i < b->height; i++) {
			memmove(b->chr + (i * b->width), b->chr + (i * b->width) - dx, sizeof(*b->chr) * (b->width + dx));
		}
		for (unsigned i = 0; i < b->height; i++) {
			memmove(b->attr + (i * b->width), b->attr + (i * b->width) - dx, sizeof(*b->attr) * (b->width + dx));
		}
		for (unsigned i = 0; i < b->height; i++) {
			vui_clrspan(b, b->width + dx - 1, b->width, i);
		}

	}
}

void vui_scroll(int dx, int dy) {
	vui_scroll_buf(vui_win.front, dx, dy);
}

int main(int argc, const char **argv) {
	vui_init();
	vui_curs_vis(0);
	signal(SIGWINCH, on_sigwinch);
	int x = 0, y = 0;
	int dx = 0, dy = 0;
	int camx = 0, camy = 0;
	int C = '*';
	unsigned frame = 0;
	int half_y = 0;
	for (;;) {
		frame++;
		//camx += dx;
		x += dx;
		if ((frame & 1) || !(half_y)) {
			// camy += dy;
			y += dy;
		}

		unsigned left = 32;
		unsigned right = vui_win.width - (left + 1);
		unsigned top = left >> half_y;
		unsigned bottom = vui_win.height - (top + 1);

		int lcamx = camx, lcamy = camy;
		if (x < left) { camx += x - left; x = left; }
		if (x > right) { camx += x - right; x = right; }
		if (y < top) { camy += y - top; y = top; }
		if (y > bottom) { camy += y - bottom; y = bottom; }

		int dcx = camx - lcamx, dcy = camy - lcamy;
		vui_scroll(-dcx, -dcy);

		/*
		if (x < 0) x += win.width;
		if (x > win.width) x -= win.width;
		if (y < 0) y += win.height;
		if (y > win.height) y -= win.height;
		*/

		static int paused = 0;

#if 1
		/* weird cellular automata */
		if (!paused) {
			// int dx = 0, dy = 0; /* shadow on purpose */

			for (int y = 0; y < vui_win.height; y++) {
				for (int x = 0; x < vui_win.width; x++) {
					if (frame & 1) {
						int txa = x, tya = y, txc = x, tyc = y;
						txa += (random() % 3) - 1;
						tya += (random() % 3) - 1;
						txc += (random() % 3) - 1;
						tyc += (random() % 3) - 1;
						if (txa >= 0 && txa < vui_win.width && tya >= 0 && tya < vui_win.height) {
							ATTR(txa, tya) = (BATTR(vui_win.back,x,y) & ~0xf) | (ATTR(txa,tya) & 0xf);
							if (!(random() & 127)) ATTR(x,y) = ATTR_DEFAULT;
						}
						if (txc >= 0 && txc < vui_win.width && tyc >= 0 && tyc < vui_win.height) {
							CHR(txc, tyc) = BCHR(vui_win.back, x, y);
							ATTR(txc, tyc) = (ATTR(txc,tyc) & ~0xf) | (BATTR(vui_win.back,x,y) & 0xf);
							if (!(random() & 127)) CHR(x,y) = ' ';
						}
					}
				}
			}

			//vui_win.redraw_all = 1;
			for (unsigned i = 0; i < isqrt(vui_win.width * vui_win.height) / 10; i++) {
				int tx = random() % vui_win.width;
				int ty = random() % vui_win.height;
				VuiAttr a = ((random()&15) << 4) | (random()&15);
				vui_chra(tx, ty, ' ' + (random() % 0x5f), a);
			}
		}

#else
		vui_clear();
		for (unsigned y = 0; y < vui_win.height; y++) {
			for (unsigned x = 0; x < vui_win.width; x++) {
				int tx = x + camx, ty = y + camy;
				char ch = " ',."[(tx^ty)&3];
				ch = ' ';
				VuiAttr a = (((tx>>2)^(ty>>2)) % 3 == 0) ? BG_WHITE : BG_RED;
				vui_chra(x, y, ch, a);
			}
		}
#endif

		vui_chra(x, y, C, ((x + y) & 0xf) | BG_BBLUE);
		vui_chra(x-1, y, C, ((x + y) & 0xf) | BG_BLUE | A_UNDERSCORE);
		vui_chra(x+1, y, C, ((x + y) & 0xf) | BG_BLUE | A_UNDERSCORE);
		vui_chra(x, y-1, C, ((x + y) & 0xf) | BG_BLUE | A_UNDERSCORE);
		vui_chra(x, y+1, C, ((x + y) & 0xf) | BG_BLUE | A_UNDERSCORE);

		vui_printf(-1, -1, "(%u, %u)", vui_win.width, vui_win.height);
		vui_printf(0, -1, "front buffer = %p", (void*)vui_win.front);
		vui_printf(-1, 0, "longest change = %3u, changes = %5u, repainted%% = %02u%%, chars = %5u", vui_max_change, vui_changes, vui_repainted * 100 / (vui_win.width * vui_win.height), vui_win.width * vui_win.height);

		// win.redraw_all = 1;
		vui_blit();

		if (!wait_for_input(STDIN_FILENO, 20)) continue;
		int c = getchar();

		if (c == 'q') break;
		if (c > 0x20 && c < 0x7f) C = c;
		switch (c) {
			/*
		case 'j': dx=-1; dy=0; break;
		case 'i': dx=0; dy=-1; break;
		case 'k': dx=0; dy=1; break;
		case 'l': dx=1; dy=0; break;
		*/
		case 'j': dx--; break;
		case 'l': dx++; break;
		case 'i': dy--; break;
		case 'k': dy++; break;
		case ' ': paused = !paused; break;
		}
	}
	vui_fini();
	printf("\x1b[2J\x1b[H %u, %u\n", vui_win.width, vui_win.height);
	return 0;
}