//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//

#define _USE_MATH_DEFINES
#include <math.h>
#include <stdio.h>

#include "../imgui.h"

#include "shader.h"

namespace OGL_Renderer
{
	// Some math headers don't have PI defined.
	static const float PI = 3.14159265f;

	void imguifree(void* ptr, void* userptr);
	void* imguimalloc(size_t size, void* userptr);

#define STBTT_malloc(x,y)    imguimalloc(x,y)
#define STBTT_free(x,y)      imguifree(x,y)
#define STB_TRUETYPE_IMPLEMENTATION
#include "../stb_truetype.h"

	void imguifree(void* ptr, void* /*userptr*/)
	{
		free(ptr);
	}

	void* imguimalloc(size_t size, void* /*userptr*/)
	{
		return malloc(size);
	}

	static const unsigned TEMP_COORD_COUNT = 100;
	static float g_tempCoords[TEMP_COORD_COUNT * 2];
	static float g_tempNormals[TEMP_COORD_COUNT * 2];

	static const int CIRCLE_VERTS = 8 * 4;
	static float g_circleVerts[CIRCLE_VERTS * 2];

	static stbtt_bakedchar g_cdata[96]; // ASCII 32..126 is 95 glyphs
	static GLuint g_ftex = 0;

	inline unsigned int RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
	{
		return (r) | (g << 8) | (b << 16) | (a << 24);
	}

	static void drawPolygon(const float* coords, unsigned numCoords, float r, unsigned int col)
	{
		if (numCoords > TEMP_COORD_COUNT) numCoords = TEMP_COORD_COUNT;

		for (unsigned i = 0, j = numCoords - 1; i < numCoords; j = i++)
		{
			const float* v0 = &coords[j * 2];
			const float* v1 = &coords[i * 2];
			float dx = v1[0] - v0[0];
			float dy = v1[1] - v0[1];
			float d = sqrtf(dx*dx + dy*dy);
			if (d > 0)
			{
				d = 1.0f / d;
				dx *= d;
				dy *= d;
			}
			g_tempNormals[j * 2 + 0] = dy;
			g_tempNormals[j * 2 + 1] = -dx;
		}

		for (unsigned i = 0, j = numCoords - 1; i < numCoords; j = i++)
		{
			float dlx0 = g_tempNormals[j * 2 + 0];
			float dly0 = g_tempNormals[j * 2 + 1];
			float dlx1 = g_tempNormals[i * 2 + 0];
			float dly1 = g_tempNormals[i * 2 + 1];
			float dmx = (dlx0 + dlx1) * 0.5f;
			float dmy = (dly0 + dly1) * 0.5f;
			float	dmr2 = dmx*dmx + dmy*dmy;
			if (dmr2 > 0.000001f)
			{
				float	scale = 1.0f / dmr2;
				if (scale > 10.0f) scale = 10.0f;
				dmx *= scale;
				dmy *= scale;
			}
			g_tempCoords[i * 2 + 0] = coords[i * 2 + 0] + dmx*r;
			g_tempCoords[i * 2 + 1] = coords[i * 2 + 1] + dmy*r;
		}

		unsigned int colTrans = RGBA(col & 0xff, (col >> 8) & 0xff, (col >> 16) & 0xff, 0);

		glBegin(GL_TRIANGLES);

		glColor4ubv((GLubyte*)&col);

		for (unsigned i = 0, j = numCoords - 1; i < numCoords; j = i++)
		{
			glVertex2fv(&coords[i * 2]);
			glVertex2fv(&coords[j * 2]);
			glColor4ubv((GLubyte*)&colTrans);
			glVertex2fv(&g_tempCoords[j * 2]);

			glVertex2fv(&g_tempCoords[j * 2]);
			glVertex2fv(&g_tempCoords[i * 2]);

			glColor4ubv((GLubyte*)&col);
			glVertex2fv(&coords[i * 2]);
		}

		glColor4ubv((GLubyte*)&col);
		for (unsigned i = 2; i < numCoords; ++i)
		{
			glVertex2fv(&coords[0]);
			glVertex2fv(&coords[(i - 1) * 2]);
			glVertex2fv(&coords[i * 2]);
		}

		glEnd();
	}

	static void drawRect(float x, float y, float w, float h, float fth, unsigned int col)
	{
		float verts[4 * 2] =
		{
			x + 0.5f, y + 0.5f,
			x + w - 0.5f, y + 0.5f,
			x + w - 0.5f, y + h - 0.5f,
			x + 0.5f, y + h - 0.5f,
		};
		drawPolygon(verts, 4, fth, col);
	}

	/*
	static void drawEllipse(float x, float y, float w, float h, float fth, unsigned int col)
	{
		float verts[CIRCLE_VERTS*2];
		const float* cverts = g_circleVerts;
		float* v = verts;

		for (int i = 0; i < CIRCLE_VERTS; ++i)
		{
			*v++ = x + cverts[i*2]*w;
			*v++ = y + cverts[i*2+1]*h;
		}

		drawPolygon(verts, CIRCLE_VERTS, fth, col);
	}
	*/

	static void drawRoundedRect(float x, float y, float w, float h, float r, float fth, unsigned int col)
	{
		const unsigned n = CIRCLE_VERTS / 4;
		float verts[(n + 1) * 4 * 2];
		const float* cverts = g_circleVerts;
		float* v = verts;

		for (unsigned i = 0; i <= n; ++i)
		{
			*v++ = x + w - r + cverts[i * 2] * r;
			*v++ = y + h - r + cverts[i * 2 + 1] * r;
		}

		for (unsigned i = n; i <= n * 2; ++i)
		{
			*v++ = x + r + cverts[i * 2] * r;
			*v++ = y + h - r + cverts[i * 2 + 1] * r;
		}

		for (unsigned i = n * 2; i <= n * 3; ++i)
		{
			*v++ = x + r + cverts[i * 2] * r;
			*v++ = y + r + cverts[i * 2 + 1] * r;
		}

		for (unsigned i = n * 3; i < n * 4; ++i)
		{
			*v++ = x + w - r + cverts[i * 2] * r;
			*v++ = y + r + cverts[i * 2 + 1] * r;
		}
		*v++ = x + w - r + cverts[0] * r;
		*v++ = y + r + cverts[1] * r;

		drawPolygon(verts, (n + 1) * 4, fth, col);
	}


	static void drawLine(float x0, float y0, float x1, float y1, float r, float fth, unsigned int col)
	{
		float dx = x1 - x0;
		float dy = y1 - y0;
		float d = sqrtf(dx*dx + dy*dy);
		if (d > 0.0001f)
		{
			d = 1.0f / d;
			dx *= d;
			dy *= d;
		}
		float nx = dy;
		float ny = -dx;
		float verts[4 * 2];
		r -= fth;
		r *= 0.5f;
		if (r < 0.01f) r = 0.01f;
		dx *= r;
		dy *= r;
		nx *= r;
		ny *= r;

		verts[0] = x0 - dx - nx;
		verts[1] = y0 - dy - ny;

		verts[2] = x0 - dx + nx;
		verts[3] = y0 - dy + ny;

		verts[4] = x1 + dx + nx;
		verts[5] = y1 + dy + ny;

		verts[6] = x1 + dx - nx;
		verts[7] = y1 + dy - ny;

		drawPolygon(verts, 4, fth, col);
	}

	bool imguiRenderGLInit(const char* fontpath)
	{
		for (int i = 0; i < CIRCLE_VERTS; ++i)
		{
			float a = (float)i / (float)CIRCLE_VERTS * PI * 2;
			g_circleVerts[i * 2 + 0] = cosf(a);
			g_circleVerts[i * 2 + 1] = sinf(a);
		}

		// Load font.
		FILE* fp = fopen(fontpath, "rb");
		if (!fp) return false;
		fseek(fp, 0, SEEK_END);
		int size = ftell(fp);
		fseek(fp, 0, SEEK_SET);

		unsigned char* ttfBuffer = (unsigned char*)malloc(size);
		if (!ttfBuffer)
		{
			fclose(fp);
			return false;
		}

		size_t len = fread(ttfBuffer, 1, size, fp);
		(void)len;

		fclose(fp);
		fp = 0;

		unsigned char* bmap = (unsigned char*)malloc(512 * 512);
		if (!bmap)
		{
			free(ttfBuffer);
			return false;
		}

		stbtt_BakeFontBitmap(ttfBuffer, 0, 15.0f, bmap, 512, 512, 32, 96, g_cdata);

		// can free ttf_buffer at this point
		glVerify(glGenTextures(1, &g_ftex));
		glVerify(glBindTexture(GL_TEXTURE_2D, g_ftex));
		glVerify(glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512, 512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, bmap));
		glVerify(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
		glVerify(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));

		free(ttfBuffer);
		free(bmap);

		return true;
	}

	void imguiRenderGLDestroy()
	{
		if (g_ftex)
		{
			glDeleteTextures(1, &g_ftex);
			g_ftex = 0;
		}
	}

	static void getBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index,
		float *xpos, float *ypos, stbtt_aligned_quad *q)
	{
		stbtt_bakedchar *b = chardata + char_index;
		int round_x = STBTT_ifloor(*xpos + b->xoff);
		int round_y = STBTT_ifloor(*ypos - b->yoff);

		q->x0 = (float)round_x;
		q->y0 = (float)round_y;
		q->x1 = (float)round_x + b->x1 - b->x0;
		q->y1 = (float)round_y - b->y1 + b->y0;

		q->s0 = b->x0 / (float)pw;
		q->t0 = b->y0 / (float)pw;
		q->s1 = b->x1 / (float)ph;
		q->t1 = b->y1 / (float)ph;

		*xpos += b->xadvance;
	}

	static const float g_tabStops[4] = { 150, 210, 270, 330 };

	static float getTextLength(stbtt_bakedchar *chardata, const char* text)
	{
		float xpos = 0;
		float len = 0;
		while (*text)
		{
			int c = (unsigned char)*text;
			if (c == '\t')
			{
				for (int i = 0; i < 4; ++i)
				{
					if (xpos < g_tabStops[i])
					{
						xpos = g_tabStops[i];
						break;
					}
				}
			}
			else if (c >= 32 && c < 128)
			{
				stbtt_bakedchar *b = chardata + c - 32;
				int round_x = STBTT_ifloor((xpos + b->xoff) + 0.5);
				len = round_x + b->x1 - b->x0 + 0.5f;
				xpos += b->xadvance;
			}
			++text;
		}
		return len;
	}

	static void drawText(float x, float y, const char *text, int align, unsigned int col)
	{
		if (!g_ftex) return;
		if (!text) return;

		if (align == IMGUI_ALIGN_CENTER)
			x -= getTextLength(g_cdata, text) / 2;
		else if (align == IMGUI_ALIGN_RIGHT)
			x -= getTextLength(g_cdata, text);

		glColor4ub(col & 0xff, (col >> 8) & 0xff, (col >> 16) & 0xff, (col >> 24) & 0xff);

		glEnable(GL_TEXTURE_2D);

		// assume orthographic projection with units = screen pixels, origin at top left
		glBindTexture(GL_TEXTURE_2D, g_ftex);

		glBegin(GL_TRIANGLES);

		const float ox = x;

		while (*text)
		{
			int c = (unsigned char)*text;
			if (c == '\t')
			{
				for (int i = 0; i < 4; ++i)
				{
					if (x < g_tabStops[i] + ox)
					{
						x = g_tabStops[i] + ox;
						break;
					}
				}
			}
			else if (c >= 32 && c < 128)
			{
				stbtt_aligned_quad q;
				getBakedQuad(g_cdata, 512, 512, c - 32, &x, &y, &q);

				glTexCoord2f(q.s0, q.t0);
				glVertex2f(q.x0, q.y0);
				glTexCoord2f(q.s1, q.t1);
				glVertex2f(q.x1, q.y1);
				glTexCoord2f(q.s1, q.t0);
				glVertex2f(q.x1, q.y0);

				glTexCoord2f(q.s0, q.t0);
				glVertex2f(q.x0, q.y0);
				glTexCoord2f(q.s0, q.t1);
				glVertex2f(q.x0, q.y1);
				glTexCoord2f(q.s1, q.t1);
				glVertex2f(q.x1, q.y1);
			}
			++text;
		}

		glEnd();
		glDisable(GL_TEXTURE_2D);
	}


	void imguiRenderGLDraw()
	{
		const imguiGfxCmd* q = imguiGetRenderQueue();
		int nq = imguiGetRenderQueueSize();

		const float s = 1.0f / 8.0f;

		glDisable(GL_SCISSOR_TEST);
		for (int i = 0; i < nq; ++i)
		{
			const imguiGfxCmd& cmd = q[i];
			if (cmd.type == IMGUI_GFXCMD_RECT)
			{
				if (cmd.rect.r == 0)
				{
					drawRect((float)cmd.rect.x*s + 0.5f, (float)cmd.rect.y*s + 0.5f,
						(float)cmd.rect.w*s - 1, (float)cmd.rect.h*s - 1,
						1.0f, cmd.col);
				}
				else
				{
					drawRoundedRect((float)cmd.rect.x*s + 0.5f, (float)cmd.rect.y*s + 0.5f,
						(float)cmd.rect.w*s - 1, (float)cmd.rect.h*s - 1,
						(float)cmd.rect.r*s, 1.0f, cmd.col);
				}
			}
			else if (cmd.type == IMGUI_GFXCMD_LINE)
			{
				drawLine(cmd.line.x0*s, cmd.line.y0*s, cmd.line.x1*s, cmd.line.y1*s, cmd.line.r*s, 1.0f, cmd.col);
			}
			else if (cmd.type == IMGUI_GFXCMD_TRIANGLE)
			{
				if (cmd.flags == 1)
				{
					const float verts[3 * 2] =
					{
						(float)cmd.rect.x*s + 0.5f, (float)cmd.rect.y*s + 0.5f,
						(float)cmd.rect.x*s + 0.5f + (float)cmd.rect.w*s - 1, (float)cmd.rect.y*s + 0.5f + (float)cmd.rect.h*s / 2 - 0.5f,
						(float)cmd.rect.x*s + 0.5f, (float)cmd.rect.y*s + 0.5f + (float)cmd.rect.h*s - 1,
					};
					drawPolygon(verts, 3, 1.0f, cmd.col);
				}
				if (cmd.flags == 2)
				{
					const float verts[3 * 2] =
					{
						(float)cmd.rect.x*s + 0.5f, (float)cmd.rect.y*s + 0.5f + (float)cmd.rect.h*s - 1,
						(float)cmd.rect.x*s + 0.5f + (float)cmd.rect.w*s / 2 - 0.5f, (float)cmd.rect.y*s + 0.5f,
						(float)cmd.rect.x*s + 0.5f + (float)cmd.rect.w*s - 1, (float)cmd.rect.y*s + 0.5f + (float)cmd.rect.h*s - 1,
					};
					drawPolygon(verts, 3, 1.0f, cmd.col);
				}
			}
			else if (cmd.type == IMGUI_GFXCMD_TEXT)
			{
				drawText(cmd.text.x, cmd.text.y, cmd.text.text, cmd.text.align, cmd.col);
			}
			else if (cmd.type == IMGUI_GFXCMD_SCISSOR)
			{
				if (cmd.flags)
				{
					glEnable(GL_SCISSOR_TEST);
					glScissor(cmd.rect.x, cmd.rect.y, cmd.rect.w, cmd.rect.h);
				}
				else
				{
					glDisable(GL_SCISSOR_TEST);
				}
			}
		}
		glDisable(GL_SCISSOR_TEST);
	}
}