#include "terml_private.h"

#ifdef _WIN32
#include "terml_windows.h"
#else
#include "terml_linux.h"
#endif

#include <cstdio>
#include <cstring>

namespace
{
	constexpr int BYTE_ONE_MASK   = 0b000000000000000000111111;
	constexpr int BYTE_TWO_MASK   = 0b000000000000111111000000;
	constexpr int BYTE_THREE_MASK = 0b000000111111000000000000;
	constexpr int BYTE_FOUR_MASK  = 0b000111000000000000000000;

	constexpr int BYTE_ONE_MASK_OFFSET   = 0;
	constexpr int BYTE_TWO_MASK_OFFSET   = BYTE_ONE_MASK_OFFSET   + 2;
	constexpr int BYTE_THREE_MASK_OFFSET = BYTE_TWO_MASK_OFFSET   + 2;
	constexpr int BYTE_FOUR_MASK_OFFSET  = BYTE_THREE_MASK_OFFSET + 2;

	constexpr int ONE_BYTE_FILL   =                         0b10000000;
	constexpr int TWO_BYTE_FILL   =                 0b1100000010000000;
	constexpr int THREE_BYTE_FILL =         0b111000001000000010000000;
	constexpr int FOUR_BYTE_FILL  = 0b11110000100000001000000010000000;

	void print_cell_impl(tcell cell)
	{
		// one-byte codepoints
		if (cell.codepoint < 0x80)
		{
			const char str[] = { cell.codepoint, '\0' };
			printf("%s", str);
		}
		// two-byte codepoints
		else if (cell.codepoint < 0x800)
		{
			const int byte_one = (cell.codepoint & BYTE_ONE_MASK) << BYTE_ONE_MASK_OFFSET;
			const int byte_two = (cell.codepoint & BYTE_TWO_MASK) << BYTE_TWO_MASK_OFFSET;
			const int utf8 = TWO_BYTE_FILL | byte_one | byte_two;
			
			const char str[] = { (utf8 & 0xFF00) >> 8, utf8 & 0xFF, '\0' };
			printf("%s", str);
		}
		// three-byte codepoints
		else if (cell.codepoint < 0x10000)
		{
			const int byte_one   = (cell.codepoint & BYTE_ONE_MASK)   << BYTE_ONE_MASK_OFFSET;
			const int byte_two   = (cell.codepoint & BYTE_TWO_MASK)   << BYTE_TWO_MASK_OFFSET;
			const int byte_three = (cell.codepoint & BYTE_THREE_MASK) << BYTE_THREE_MASK_OFFSET;
			const int utf8 = THREE_BYTE_FILL | byte_one | byte_two | byte_three;

			const char str[] = { (utf8 & 0xFF0000) >> 16, (utf8 & 0xFF00) >> 8, utf8 & 0xFF, '\0' };
			printf("%s", str);
		}
		// four-byte codepoints
		else if (cell.codepoint < 0x110000)
		{
			const int byte_one   = (cell.codepoint & BYTE_ONE_MASK)   << BYTE_ONE_MASK_OFFSET;
			const int byte_two   = (cell.codepoint & BYTE_TWO_MASK)   << BYTE_TWO_MASK_OFFSET;
			const int byte_three = (cell.codepoint & BYTE_THREE_MASK) << BYTE_THREE_MASK_OFFSET;
			const int byte_four  = (cell.codepoint & BYTE_FOUR_MASK)  << BYTE_FOUR_MASK_OFFSET;
			const int utf8 = FOUR_BYTE_FILL | byte_one | byte_two | byte_three | byte_four;

			const char str[] = { (utf8 & 0xFF000000) >> 24, (utf8 & 0xFF0000) >> 16, (utf8 & 0xFF00) >> 8, utf8 & 0xFF, '\0' };
			printf("%s", str);
		}
	}

	void print_cell(tcell cell, const tcell* last = nullptr)
	{
		if (!last || cell.foreground != last->foreground)
		{
			printf(FG(%d, %d, %d), (cell.foreground & 0xFF0000) >> 16, (cell.foreground & 0xFF00) >> 8, cell.foreground & 0xFF);
		}
		if (!last || cell.background != last->background)
		{
			printf(BG(%d, %d, %d), (cell.background & 0xFF0000) >> 16, (cell.background & 0xFF00) >> 8, cell.background & 0xFF);
		}

		print_cell_impl(cell);
	}

	bool operator==(const tcell& a, const tcell& b)
	{
		return
			a.background == b.background &&
			a.foreground == b.foreground &&
			a.codepoint  == b.codepoint;
	}

	bool operator!=(const tcell& a, const tcell& b)
	{
		return
			a.background != b.background ||
			a.foreground != b.foreground ||
			a.codepoint  != b.codepoint;
	}
}

terml::terml() :
	cells(nullptr),
	width(0),
	height(0),
	main(nullptr),
	quit(nullptr),
	key(nullptr),
	resize(nullptr),
	should_quit(false),
	really_should_quit(false)
{
}

terml::~terml()
{
	if (cells) { delete[] cells; }
}

tcell terml::get(unsigned int x, unsigned int y) const
{
	return cells[x + y * width].cell;
}

void terml::set(unsigned int x, unsigned int y, tcell cell)
{
	cells[x + y * width].dirty = (cell != cells[x + y * width].cell);
	cells[x + y * width].cell = cell;
}

void terml::flush() const
{
	const tcell* last = nullptr;
	if (cells[0].dirty)
	{
		printf(CUP(1, 1));
		print_cell(cells[0].cell);
		cells[0].dirty = false;

		last = &cells[0].cell;
	}
	for (int i = 1; i < width * height; i++)
	{
		const unsigned int x = i % width;
		const unsigned int y = i / width;

		if (cells[i].dirty)
		{
			printf(CUP(%d, %d), y + 1, x + 1);
			print_cell(cells[i].cell, last);
			cells[i].dirty = false;
			
			last = &cells[i].cell;
		}
	}

	fflush(stdout);
}

void terml::set_main_callback(terml_main_callback callback)
{
	main = callback;
}

void terml::set_quit_callback(terml_quit_callback callback)
{
	quit = callback;
}

void terml::set_key_callback(terml_key_callback callback)
{
	key = callback;
}

void terml::set_resize_callback(terml_resize_callback callback)
{
	resize = callback;
}

void terml::key_event(char code) const
{
	if (key)
	{
		key(code);
	}
}

void terml::mainloop()
{
	should_quit = false;
	really_should_quit = false;

	const unsigned long long wait_time = timer_frequency() / 60;
	unsigned long long last_time = timer();

	while (!really_should_quit)
	{
		unsigned long long current_time = timer();

		while (current_time >= last_time + wait_time)
		{
			if (main)
			{
				main();
			}

			process_events();

			last_time = current_time;
		}

		if (should_quit)
		{
			if (!quit || quit())
			{
				really_should_quit = true;
			}
			else
			{
				should_quit = false;
			}
		}
	}
}

void terml::stop()
{
	should_quit = true;
}

unsigned int terml::get_width() const
{
	return width;
}

unsigned int terml::get_height() const
{
	return height;
}

void terml::setup_buffer()
{
	printf(CUP(999, 999) REPORT_CUSROR_POSITION());
	fflush(stdout);

	constexpr const unsigned int STDIN_BUFFER_SIZE = 16;
	char stdin_buffer[STDIN_BUFFER_SIZE + 1];
	read_stdin(stdin_buffer, STDIN_BUFFER_SIZE);

	stdin_buffer[STDIN_BUFFER_SIZE] = '\0';

	const unsigned int new_width = width;
	const unsigned int new_height = height;
	const int scanned = sscanf(stdin_buffer, CURSOR_POSITION_FORMAT(), &new_height, &new_width);
	if (scanned != 2)
	{
		throw "Failed to determine screen size.";
	}

	if (width != new_width || height != new_height)
	{
		const unsigned int old_width = width;
		const unsigned int old_height = height;

		width = new_width;
		height = new_height;

		if (cells) { delete[] cells; }
		cells = new tcelld[width * height];
		memset(cells, 0, sizeof(tcelld) * width * height);

		if (resize)
		{
			resize(old_width, old_height);
		}
	}
}

void terml::set_console_settings()
{
	setvbuf(stdout, nullptr, _IOFBF, BUFSIZ * BUFSIZ);
	printf(ALT_BUF() HIDE_CURSOR());
	fflush(stdout);

	set_console_settings_impl();
}

void terml::reset_console_settings()
{
	setvbuf(stdout, nullptr, _IOLBF, BUFSIZ);
	printf(REG_BUF() SHOW_CURSOR());
	fflush(stdout);

	reset_console_settings_impl();
}

namespace
{
	terml* TERML_G;
	const char* LAST_ERROR = nullptr;
}

extern "C"
{
	int terml_init()
	{
		try
		{
			if (!TERML_G)
			{
#ifdef _WIN32
				TERML_G = new terml_windows;
#else
				TERML_G = new terml_linux;
#endif
			}
			else
			{
				throw "terml already initialized.";
			}

			TERML_G->set_console_settings();
			TERML_G->setup_buffer();

			return 0;
		}
		catch (const char* c)
		{
			LAST_ERROR = c;
			return 1;
		}
	}

	int terml_deinit()
	{
		try
		{
			if (TERML_G)
			{
				TERML_G->reset_console_settings();
				delete TERML_G;
			}

			return 0;
		}
		catch (const char* c)
		{
			LAST_ERROR = c;
			return 1;
		}
	}

	unsigned int terml_get_width()
	{
		return TERML_G->get_width();
	}

	unsigned int terml_get_height()
	{
		return TERML_G->get_height();
	}

	tcell terml_get(unsigned int x, unsigned int y)
	{
		if (x >= TERML_G->get_width() || y >= TERML_G->get_height())
		{
			LAST_ERROR = "Coordinates out of bounds.";
			return { 0, 0, 0 };
		}
		else
		{
			return TERML_G->get(x, y);
		}
	}

	void terml_set(unsigned int x, unsigned int y, tcell cell)
	{
		if (x >= TERML_G->get_width() || y >= TERML_G->get_height())
		{
			LAST_ERROR = "Coordinates out of bounds.";
		}
		else
		{
			TERML_G->set(x, y, cell);
		}
	}

	void terml_flush()
	{
		TERML_G->flush();
	}

	void terml_set_main_callback(terml_main_callback callback)
	{
		TERML_G->set_main_callback(callback);
	}

	void terml_set_quit_callback(terml_quit_callback callback)
	{
		TERML_G->set_quit_callback(callback);
	}

	void terml_set_key_callback(terml_key_callback callback)
	{
		TERML_G->set_key_callback(callback);
	}

	void terml_set_resize_callback(terml_resize_callback callback)
	{
		TERML_G->set_resize_callback(callback);
	}

	void terml_start()
	{
		try
		{
			TERML_G->mainloop();
		}
		catch (const char* c)
		{
			LAST_ERROR = c;
		}
	}

	void terml_stop()
	{
		TERML_G->stop();
	}

	const char* terml_get_error()
	{
		const char* err = LAST_ERROR;
		LAST_ERROR = nullptr;
		return err;
	}
}