#include "private.h"

#include "world.h"

#include "framebuffer.h"

#include "drawing.h"

typedef struct _HeliFramebufferDesc {

	unsigned int texture_id;

	unsigned int renderbuffer_id;

	unsigned int framebuffer_id;

} HeliFramebufferDesc;

struct _Framebuffer {

	int width;

	int height;

	HeliFramebufferDesc base;

	HeliFramebufferDesc multisample;

};

static void heliInitFramebuffer(

	HeliFramebufferDesc *fbd,

	int width,

	int height,

	const void *pixels,

	int horWrap,

	int vertWrap,

	int smooth,

	int multisample,

	int simple

) {

	fbd->texture_id = 0;

	fbd->renderbuffer_id = 0;

	fbd->framebuffer_id = 0;

	unsigned int texTargetBinding = multisample ? GL_TEXTURE_BINDING_2D_MULTISAMPLE : GL_TEXTURE_BINDING_2D;

	unsigned int texTarget = multisample ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;

	unsigned int prev = 0;

	glGetIntegerv(texTargetBinding, (int*)&prev);

	glGenTextures(1, &fbd->texture_id);

	glBindTexture(texTarget, fbd->texture_id);

	if (multisample) {

		heliGLTexImage2DMultisamplePtr(texTarget, multisample, GL_RGBA, width, height, GL_TRUE);

	} else {

		glTexParameteri(texTarget, GL_TEXTURE_MAG_FILTER, smooth ? GL_LINEAR : GL_NEAREST);

		glTexParameteri(texTarget, GL_TEXTURE_MIN_FILTER, smooth ? GL_LINEAR : GL_NEAREST);

		glTexParameteri(texTarget, GL_TEXTURE_WRAP_S, horWrap ? GL_REPEAT : GL_CLAMP_TO_EDGE);

		glTexParameteri(texTarget, GL_TEXTURE_WRAP_T, vertWrap ? GL_REPEAT : GL_CLAMP_TO_EDGE);

		glTexImage2D(texTarget, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

	}

	glBindTexture(texTarget, prev);

	if (!simple) {

		glGetIntegerv(GL_RENDERBUFFER_BINDING, (int*)&prev);

		heliGLGenRenderbuffersPtr(1, &fbd->renderbuffer_id);

		heliGLBindRenderbufferPtr(GL_RENDERBUFFER, fbd->renderbuffer_id);

		if (multisample) heliGLRenderbufferStorageMultisamplePtr(GL_RENDERBUFFER, multisample, GL_DEPTH24_STENCIL8, width, height);

		            else heliGLRenderbufferStoragePtr(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);

		heliGLBindRenderbufferPtr(GL_RENDERBUFFER, prev);

	}

	glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prev);

	heliGLGenFramebuffersPtr(1, &fbd->framebuffer_id);

	heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, fbd->framebuffer_id);

	if (fbd->renderbuffer_id)

		heliGLFramebufferRenderbufferPtr(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbd->renderbuffer_id);

	heliGLFramebufferTexture2DPtr(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texTarget, fbd->texture_id, 0);

	heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prev);

}

static void heliDeinitFramebuffer(HeliFramebufferDesc *fbd) {

	if (fbd->framebuffer_id) {

		unsigned int id = 0;

		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&id);

		if (id == fbd->framebuffer_id) heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, 0);

		glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (int*)&id);

		if (id == fbd->framebuffer_id) heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, 0);

		heliGLDeleteFramebuffersPtr(1, &fbd->framebuffer_id);

		fbd->framebuffer_id = 0;

	}

	if (fbd->renderbuffer_id) {

		heliGLDeleteRenderbuffersPtr(1, &fbd->renderbuffer_id);

		fbd->renderbuffer_id = 0;

	}

	if (fbd->texture_id) {

		glDeleteTextures(1, &fbd->texture_id);

		fbd->texture_id = 0;

	}

}

Framebuffer createFramebufferEx(int width, int height, const void *pixels, int horWrap, int vertWrap, int smooth) {

	Framebuffer fb = calloc(1, sizeof(*fb));

	heliObjectRegister(fb, (HeliFreeCallback)&framebufferDestroy);

	if (width <= 0 || height <= 0) {

		fprintf(stderr, "helianthus: cannot create framebuffer, bad size: %dx%d\n", width, height);

		return fb;

	}

	if (!heliGLGenFramebuffersPtr || !heliGLGenRenderbuffersPtr) {

		fprintf(stderr, "helianthus: cannot create framebuffer, seems OpenGL version is too low\n");

		return fb;

	}

	fb->width = width;

	fb->height = height;

	heliInitFramebuffer(&fb->base, width, height, pixels, horWrap, vertWrap, smooth, 0, FALSE);

	unsigned int err = 0;

	glGetError();

	if (heliGLTexImage2DMultisamplePtr && heliGLRenderbufferStorageMultisamplePtr) {

		for(int multisample = 8; multisample >= 4; multisample /= 2) {

			glGetError();

			heliInitFramebuffer(&fb->multisample, width, height, NULL, FALSE, FALSE, FALSE, multisample, FALSE);

			err = glGetError();

			if (err == GL_NO_ERROR) {

				if (pixels) {

					unsigned int prevR = 0, prevD = 0;

					glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (int*)&prevR);

					glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prevD);

					heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, fb->base.framebuffer_id);

					heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, fb->multisample.framebuffer_id);

					heliGLBlitFramebufferPtr(0, 0, fb->width, fb->height, 0, 0, fb->width, fb->height, GL_COLOR_BUFFER_BIT, GL_NEAREST);

					heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, prevR);

					heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

				}

				break;

			}

			heliDeinitFramebuffer(&fb->multisample);

		}

	}

	unsigned int prevD = 0;

	glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prevD);

	if (!fb->multisample.framebuffer_id) {

		fprintf(stderr, "helianthus: cannot initialize multisampling for framebuffer, OpenGL error code: 0x%04x\n", err);

	} else {

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, fb->multisample.framebuffer_id);

		err = heliGLCheckFramebufferStatusPtr(GL_DRAW_FRAMEBUFFER);

		if (err != GL_FRAMEBUFFER_COMPLETE) {

			fprintf(stderr, "helianthus: multisampling framebuffer in incomplete, status: 0x%04x, OpenGL error code: 0x%04x\n", err, glGetError());

			heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

			heliDeinitFramebuffer(&fb->multisample);

		}

	}

	heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, fb->multisample.framebuffer_id);

	err = heliGLCheckFramebufferStatusPtr(GL_DRAW_FRAMEBUFFER);

	if (err != GL_FRAMEBUFFER_COMPLETE) {

		fprintf(stderr, "helianthus: base framebuffer in incomplete, status: 0x%04x, OpenGL error code: 0x%04x", err, glGetError());

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

		heliDeinitFramebuffer(&fb->base);

	}

	heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

	return fb;

}

Framebuffer createFramebuffer(int width, int height)

	{ return createFramebufferEx(width, height, NULL, FALSE, FALSE, TRUE); }

Framebuffer createFramebufferFromFile(const char *path) {

	int width = 0;

	int height = 0;

	unsigned char *pixels = NULL;

	imageLoad(path, &width, &height, &pixels);

	return createFramebufferEx(width, height, pixels, FALSE, FALSE, TRUE);

}

void framebufferDestroy(Framebuffer framebuffer) {

	HeliDrawingState *ss = heliDrawingGetState();

	if (framebuffer->base.texture_id)

		heliUIntRemove(&heliDrawingFramebuffersToFlush, framebuffer->base.texture_id);

	if (framebuffer->base.framebuffer_id) {

		for(HeliDrawingState *s = heliDrawingGetStateStack(); s <= ss; ++s) {

			if (ss->glState.framebuffer_read_id == framebuffer->base.framebuffer_id)

				ss->glState.framebuffer_read_id = 0;

			if (ss->glState.framebuffer_draw_id == framebuffer->base.framebuffer_id)

				ss->glState.framebuffer_draw_id = 0;

		}

	}

	if (framebuffer->multisample.framebuffer_id) {

		for(HeliDrawingState *s = heliDrawingGetStateStack(); s <= ss; ++s) {

			if (ss->glState.framebuffer_read_id == framebuffer->multisample.framebuffer_id)

				ss->glState.framebuffer_read_id = 0;

			if (ss->glState.framebuffer_draw_id == framebuffer->multisample.framebuffer_id)

				ss->glState.framebuffer_draw_id = 0;

		}

	}

	heliDeinitFramebuffer(&framebuffer->multisample);

	heliDeinitFramebuffer(&framebuffer->base);

	free(framebuffer);

}

void framebufferFlush(Framebuffer framebuffer) {

	if (framebuffer->base.texture_id)

		heliUIntRemove(&heliDrawingFramebuffersToFlush, framebuffer->base.texture_id);

	if (framebuffer->base.framebuffer_id && framebuffer->multisample.framebuffer_id) {

		unsigned int prevR = 0, prevD = 0;

		glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (int*)&prevR);

		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prevD);

		heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, framebuffer->multisample.framebuffer_id);

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, framebuffer->base.framebuffer_id);

		heliGLBlitFramebufferPtr(

			0, 0, framebuffer->width, framebuffer->height,

			0, 0, framebuffer->width, framebuffer->height,

			GL_COLOR_BUFFER_BIT, GL_NEAREST );

		heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, prevR);

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

	}

}

int framebufferGetWidth(Framebuffer framebuffer)

	{ return framebuffer->width; }

int framebufferGetHeight(Framebuffer framebuffer)

	{ return framebuffer->height; }

unsigned int framebufferGetGLTexId(Framebuffer framebuffer)

	{ return framebuffer->base.texture_id; }

unsigned int framebufferGetGLId(Framebuffer framebuffer) {

	return framebuffer->multisample.framebuffer_id

	     ? framebuffer->multisample.framebuffer_id

	     : framebuffer->base.framebuffer_id;

}

int imageFromViewport(int *outWidth, int *outHeight, unsigned char **outPixels) {

	*outWidth = 0;

	*outHeight = 0;

	*outPixels = NULL;

	int vp[4] = {};

	glGetIntegerv(GL_VIEWPORT, vp);

	if (vp[2] <= 0 || vp[3] <= 0) return FALSE;

	unsigned int prevR = 0, prevD = 0;

	glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prevR);

	unsigned char *buffer = malloc(vp[2]*vp[3]*4);

	glGetError();

	glReadPixels(vp[0], vp[1], vp[2], vp[3], GL_RGBA, GL_UNSIGNED_BYTE, buffer);

	if (glGetError() != GL_NO_ERROR) {

		if (!heliGLBindFramebufferPtr || !heliGLBlitFramebufferPtr) {

			fprintf(stderr, "helianthus: cannot read viewport pixels\n");

			free(buffer);

			return FALSE;

		}

		// blit multisample buffer

		HeliFramebufferDesc fbd = {};

		heliInitFramebuffer(&fbd, vp[2], vp[3], NULL, FALSE, FALSE, FALSE, 0, TRUE);

		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&prevD);

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, fbd.framebuffer_id);

		heliGLBlitFramebufferPtr(vp[0], vp[1], vp[2], vp[3], 0, 0, vp[2], vp[3], GL_COLOR_BUFFER_BIT, GL_NEAREST);

		heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, fbd.framebuffer_id);

		glReadPixels(0, 0, vp[2], vp[3], GL_RGBA, GL_UNSIGNED_BYTE, buffer);

		heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, prevR);

		heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, prevD);

		heliDeinitFramebuffer(&fbd);

	}

	// flip image

	if (!prevR) {

		size_t rowSize = vp[2]*4;

		unsigned char *row = malloc(rowSize);

		for(int i = vp[3]/2 - 1; i >= 0; --i) {

			unsigned char *r0 = buffer + rowSize*i;

			unsigned char *r1 = buffer + rowSize*(vp[3]-i-1);

			memcpy(row, r0, rowSize);

			memcpy(r0, r1, rowSize);

			memcpy(r1, row, rowSize);

		}

	}

	*outWidth = vp[2];	

	*outHeight = vp[3];

	*outPixels = buffer;

	return TRUE;

}