#include <SDL_image.h>

#include "private.h"

#include "sprite.h"

#include "window.h"

#include "animation.h"

static HeliArray cache;

static Animation first, last;

typedef struct _HeliTexture {

	const char *key;

	unsigned int id;

	int own;

	int refcount;

} HeliTexture;

struct _Animation {

	int playing;

	int loop;

	double fps;

	double pos;

	HeliArray frames;

	Animation prev, next;

};

static int fixsize(int x) {

	int p = (int)ceil(log2(x > 1 ? x : 1) - 0.25);

	if (p > 30) p = 30;

	return 1 << p;

}

static float colorclamp(float x)

	{ return x > 0.f ? (x < 1.f ? x : 1.f) : 0.f; }

static void mipx(float *buffer, int *w, int *h) {

	*w /= 2;

	if (*w <= 0) return;

	for(float *d = buffer, *s = buffer, *end = d + (*w)*(*h)*4; d < end; d += 4, s += 8)

		for(int i = 0; i < 4; ++i)

			d[i] = (s[i] + s[i + 4])*0.5f;

}

static void mipy(float *buffer, int *w, int *h) {

	*h /= 2;

	if (*h <= 0) return;

	int rstep = (*w)*4;

	float *d = buffer, *s0 = buffer, *s1 = s0 + rstep;

	for(float *end = d + (*h)*rstep; d < end; s0 += rstep, s1 += rstep)

		for(float *rend = d + rstep; d < rend; ++d, ++s0, ++s1)

			*d = (*s0 + *s1)*0.5f;

}

int imageLoadFromSDL(SDL_Surface *surface, int *outWidth, int *outHeight, unsigned char **outPixels) {

	*outWidth = 0;

	*outHeight = 0;

	*outPixels = NULL;

	if (!surface) return FALSE;

	// convert to RGBA

	if (surface->format->format != SDL_PIXELFORMAT_RGBA8888) {

		SDL_PixelFormat *format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA8888);

		SDL_Surface *converted = SDL_ConvertSurface(surface, format, 0);

		SDL_FreeFormat(format);

		surface = converted;

	}

	// copy

	SDL_LockSurface(surface);

	int w = surface->w;

	int h = surface->h;

	assert(w > 0 && h > 0);

	size_t rsize = (size_t)w*4;

	unsigned char *pixels = malloc(h*rsize);

	for(int i = 0; i < h; ++i) {

		const unsigned char *pp = surface->pixels + surface->pitch*i;

		for(unsigned char *p = pixels + i*rsize, *end = p + rsize; p < end; p += 4, pp += 4) {

			p[0] = pp[3];

			p[1] = pp[2];

			p[2] = pp[1];

			p[3] = pp[0];

		}

	}

	SDL_UnlockSurface(surface);

	*outPixels = pixels;

	*outWidth = w;

	*outHeight = h;

	return TRUE;

}

int imageLoadFromMemory(const void *data, int size, int *outWidth, int *outHeight, unsigned char **outPixels) {

	SDL_RWops *rw = data && size > 0 ? SDL_RWFromMem((void*)data, size) : NULL;

	SDL_Surface *surface = rw ? IMG_Load_RW(rw, SDL_TRUE) : NULL;

	int res = imageLoadFromSDL(surface, outWidth, outHeight, outPixels);

	if (surface) {

		SDL_FreeSurface(surface);

	} else {

		fprintf(stderr, "helianthus: cannot load image from memory\n");

	}

	return res;

}

int imageLoad(const char *path, int *outWidth, int *outHeight, unsigned char **outPixels) {

	SDL_Surface *surface = IMG_Load(path);

	int res = imageLoadFromSDL(surface, outWidth, outHeight, outPixels);

	if (surface) {

		SDL_FreeSurface(surface);

	} else {

		fprintf(stderr, "helianthus: cannot load image: %s\n", path);

	}

	return res;

}

int imageSave(const char *path, int width, int height, const void *pixels) {

	#if SDL_BYTEORDER == SDL_BIG_ENDIAN

		Uint32 rm = 0xff000000,

		       gm = 0x00ff0000,

		       bm = 0x0000ff00,

		       am = 0x000000ff;

	#else

		Uint32 rm = 0x000000ff,

		       gm = 0x0000ff00,

		       bm = 0x00ff0000,

		       am = 0xff000000;

	#endif

	SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(SDL_const_cast(void*, pixels), width, height, 32, width*4, rm, gm, bm, am);

	if (!surface) {

		fprintf(stderr, "helianthus: cannot create SDL surface to save image: %s\n", SDL_GetError());

		return FALSE;

	}

	if (IMG_SavePNG(surface, path) != 0) {

		fprintf(stderr, "helianthus: cannot save image to file: %s, : %s\n", path, SDL_GetError());

		SDL_FreeSurface(surface);

		return FALSE;

	}

	SDL_FreeSurface(surface);

	return TRUE;

}

unsigned int imageToGLTexture(int width, int height, const void *pixels, int wrap)

	{ return imageToGLTextureEx(width, height, pixels, wrap, wrap, TRUE, TRUE); }

int imageToExistingGLTexture(unsigned int texid, int width, int height, const void *pixels) {

	if (!texid || width <= 0 || height <= 0 || !pixels) return FALSE;

	// convert to float and premult alpha

	size_t count = (size_t)width*height*4;

	float *buffer = (float*)malloc(count*sizeof(float));

	const unsigned char *pp = (const unsigned char *)pixels;

	for(float *p = buffer, *end = p + count; p < end; p += 4, pp += 4) {

		if (pp[3]) {

			float a = pp[3]/255.f;

			p[0] = pp[0]/255.f*a;

			p[1] = pp[1]/255.f*a;

			p[2] = pp[2]/255.f*a;

			p[3] = a;

		} else {

			p[0] = p[1] = p[2] = p[3] = 0;

		}

	}

	// resample to power of two

	int w = width, h = height;

	int fw = fixsize(w);

	int fh = fixsize(h);

	if (fw != w || fh != h) {

		float *fbuffer = (float*)malloc((size_t)fw*fh*4*sizeof(float));

		double kr = (double)h/fh;

		double kc = (double)w/fw;

		for(int r = 0; r < fh; ++r) {

			for(int c = 0; c < fw; ++c) {

				double pr1 = r*kr;

				int r0 = (int)floor(pr1 + HELI_PRECISION);

				pr1 -= r0;

				int r1 = r0 + 1;

				if (r1 >= h) r1 = h - 1;

				if (r0 > r1) r0 = r1;

				double pr0 = 1 - pr1;

				double pc1 = c*kc;

				int c0 = (int)floor(pc1 + HELI_PRECISION);

				pc1 -= c0;

				int c1 = c0 + 1;

				if (c1 >= w) c1 = w - 1;

				if (c0 > c1) c0 = c1;

				double pc0 = 1 - pc1;

				float *p = fbuffer + (r*fw + c)*4;

				const float *p00 = buffer + (r0*w + c0)*4;

				const float *p01 = buffer + (r0*w + c1)*4;

				const float *p10 = buffer + (r1*w + c0)*4;

				const float *p11 = buffer + (r1*w + c1)*4;

				for(int i = 0; i < 4; ++i)

					p[i] = p00[i]*pr0*pc0

					     + p01[i]*pr0*pc1

					     + p10[i]*pr1*pc0

					     + p11[i]*pr1*pc1;

			}

		}

		free(buffer);

		buffer = fbuffer;

		w = fw;

		h = fh;

	}

	// fix max texture size

	int maxSize = 0;

	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);

	if (maxSize < 64) maxSize = 64;

	while(w > maxSize) mipx(buffer, &w, &h);

	while(h > maxSize) mipy(buffer, &w, &h);

	// upload to OpenGL texture

	unsigned int prevtex = 0;

	int minFilter = 0;

	glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

	glBindTexture(GL_TEXTURE_2D, texid);

	glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);

	int mipMap = minFilter == GL_NEAREST_MIPMAP_NEAREST

	          || minFilter == GL_NEAREST_MIPMAP_LINEAR

	          || minFilter == GL_LINEAR_MIPMAP_NEAREST

	          || minFilter == GL_LINEAR_MIPMAP_LINEAR;

	// build mip levels

	unsigned char *ibuffer = malloc((size_t)w*h*4);

	int level = 0;

	while(1) {

		float *pp = buffer;

		for(unsigned char *p = ibuffer, *end = p + (size_t)w*h*4; p < end; p += 4, pp += 4) {

			if (pp[3] > 1e-5) {

				float k = 1/pp[3];

				p[0] = (unsigned char)floor(colorclamp(pp[0]*k)*255.99);

				p[1] = (unsigned char)floor(colorclamp(pp[1]*k)*255.99);

				p[2] = (unsigned char)floor(colorclamp(pp[2]*k)*255.99);

				p[3] = (unsigned char)floor(colorclamp(pp[3])*255.99);

			} else {

				p[0] = (unsigned char)floor(colorclamp(pp[0])*255.99);

				p[1] = (unsigned char)floor(colorclamp(pp[1])*255.99);

				p[2] = (unsigned char)floor(colorclamp(pp[2])*255.99);

				p[3] = 0;

			}

		}

		glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ibuffer);

		++level;

		if (!mipMap) break;

		if (w <= 1 && h <= 1) break;

		if (w > 1) mipx(buffer, &w, &h);

		if (h > 1) mipy(buffer, &w, &h);

	}

	// done

	free(ibuffer);

	free(buffer);

	glBindTexture(GL_TEXTURE_2D, prevtex);

	return TRUE;

}

unsigned int imageToGLTextureEx(int width, int height, const void *pixels, int horWrap, int vertWrap, int smooth, int mipMap) {

	// create OpenGL texture

	unsigned int texid = 0, prevtex = 0;

	glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

	glGenTextures(1, &texid);

	glBindTexture(GL_TEXTURE_2D, texid);

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

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, smooth ? (mipMap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR): (mipMap ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST));

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

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

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -0.7f);

	imageToExistingGLTexture(texid, width, height, pixels);

	glBindTexture(GL_TEXTURE_2D, prevtex);

	return texid;

}

int imageFromGLTexture(unsigned int texid, int *outWidth, int *outHeight, unsigned char **outPixels) {

	*outWidth = *outHeight = 0; *outPixels = NULL;

	int w = 0, h = 0;

	unsigned int prevtex = 0;

	glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

	glBindTexture(GL_TEXTURE_2D, texid);

	glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);

	glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &h);

	if (w > 0 && h > 0) {

		*outWidth = w;

		*outHeight = h;

		*outPixels = malloc(sizeof(**outPixels)*w*h*4);

		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, *outPixels);

	}

	glBindTexture(GL_TEXTURE_2D, prevtex);

	return outPixels != NULL;

}

int viewportSave(const char *path) {

	int width = 0;

	int height = 0;

	unsigned char *pixels = NULL;

	if (!imageFromViewport(&width, &height, &pixels)) return FALSE;

	int result = imageSave(path, width, height, pixels);

	free(pixels);

	return result;

}

unsigned int pixelGet(const void *pixel) {

	const unsigned char *p = (const unsigned char *)pixel;

	return (((unsigned int)p[0]) << 24)

	     | (((unsigned int)p[1]) << 16)

		 | (((unsigned int)p[2]) <<  8)

		 | (((unsigned int)p[3]) <<  0);

}

void pixelSet(void *pixel, unsigned int colorCode) {

	unsigned char *p = (unsigned char *)pixel;

	p[0] = (colorCode >> 24);

	p[1] = (colorCode >> 16) & 0xFF;

	p[2] = (colorCode >>  8) & 0xFF;

	p[3] = (colorCode      ) & 0xFF;

}

unsigned int imageGetPixel(int width, int height, const void *pixels, int x, int y) {

	if (x < 0 || x >= width || y < 0 || y >= height || !pixels) return 0;

	return pixelGet((const unsigned char *)pixels + 4*((size_t)width*y + x));

}

void imageSetPixel(int width, int height, void *pixels, int x, int y, unsigned int colorCode) {

	if (x < 0 || x >= width || y < 0 || y >= height || !pixels) return;

	pixelSet((unsigned char *)pixels + 4*((size_t)width*y + x), colorCode);

}

static void unloadTexture(HeliTexture *texture) {

	assert(!texture->refcount);

	if (texture->own && texture->id) {

		unsigned int prevtex = 0;

		glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

		if (prevtex == texture->id) glBindTexture(GL_TEXTURE_2D, 0);

		glDeleteTextures(1, &texture->id);

	}

}

static HeliTexture* loadTexture(const char *key) {

	HeliTexture *texture = calloc(1, sizeof(*texture));

	texture->key = heliStringCopy(key);

	texture->own = TRUE;

	if (key[0] == 'T') {

		texture->id = (unsigned int)atoll(key + 3);

	} else {

		int w = 0, h = 0;

		unsigned char *pixels = NULL;

		if (imageLoad(key+3, &w, &h, &pixels)) {

			texture->id = imageToGLTextureEx(w, h, pixels, key[1] == 'W', key[2] == 'W', key[0] == 'L', TRUE);

			free(pixels);

		}

	}

	return texture;

}

static HeliTexture *getTexture(const char *key) {

	HeliPair *item = heliStringmapGet(&cache, key);

	if (!item) item = heliStringmapAdd(&cache, key, loadTexture(key), (HeliFreeCallback)&unloadTexture);

	HeliTexture *texture = (HeliTexture*)item->value;

	++texture->refcount;

	return texture;

}

static void unrefTexture(HeliTexture *texture) {

	if (--texture->refcount <= 0)

		heliStringmapRemove(&cache, texture->key);

}

static void heliAnimationFixPos(Animation animation) {

	double maxPos = animation->frames.count - HELI_PRECISION_SQR;

	if (!(animation->pos < maxPos)) animation->pos = maxPos;

	if (!(animation->pos > 0)) animation->pos = 0;

}

Animation createAnimationEmpty() {

	Animation animation = calloc(1, sizeof(*animation));

	animation->prev = last;

	*(animation->prev ? &animation->prev->next : &first) = last = animation;

	double minFps = windowGetMinFrameRate();

	double maxFps = windowGetMaxFrameRate();

	animation->fps = HELI_DEFAULT_FPS;

	if (animation->fps > maxFps) animation->fps = maxFps;

	if (animation->fps < minFps) animation->fps = minFps;

	animation->loop = TRUE;

	heliObjectRegister(animation, (HeliFreeCallback)&animationDestroy);

	return animation;

}

Animation createAnimationEx(const char* path, int smooth, int horWrap, int vertWrap) {

	Animation animation = createAnimationEmpty();

	char *key = heliStringConcat("NCC", path);

	if (smooth) key[0] = 'L';

	if (horWrap) key[1] = 'W';

	if (vertWrap) key[2] = 'W';

	Directory d = openDirectory(key + 3);

	if (d) {

		int count = directoryGetCount(d);

		for(int i = 0; i < count; ++i) {

			const char *file = directoryGet(d, i);

			if (heliStringEndsWithLowcase(file, ".png")) {

				char *k = heliStringConcat3(key, "/", file);

				heliArrayInsert(&animation->frames, -1, getTexture(k), (HeliFreeCallback)&unrefTexture);

				free(k);

			}

		}

		closeDirectory(d);

	} else {

		heliArrayInsert(&animation->frames, -1, getTexture(key), (HeliFreeCallback)&unrefTexture);

	}

	return animation;

}

Animation createAnimationFromGLTexId(unsigned int texid) {

	Animation animation = createAnimationEmpty();

	char key[256] = "TTT";

	sprintf(key+3, "%d", texid);

	heliArrayInsert(&animation->frames, -1, getTexture(key), (HeliFreeCallback)&unrefTexture);

	return animation;

}

void animationGLTexIdSetOwnership(unsigned int texid, int own) {

	char key[256] = "TTT";

	sprintf(key+3, "%d", texid);

	HeliPair *item = heliStringmapGet(&cache, key);

	if (item) {

		HeliTexture *texture = (HeliTexture*)item->value;

		texture->own = own != 0;

	}

}

Animation createAnimationFromImageEx(int width, int height, const void *pixels, int horWrap, int vertWrap, int smooth, int mipMap)

	{ return createAnimationFromGLTexId(imageToGLTextureEx(width, height, pixels, horWrap, vertWrap, smooth, mipMap)); }

Animation createAnimationFromImage(int width, int height, const void *pixels, int wrap)

	{ return createAnimationFromGLTexId(imageToGLTexture(width, height, pixels, wrap)); }

Animation createAnimationFromFramebuffer(Framebuffer framebuffer) {

	unsigned int texid = framebufferGetGLTexId(framebuffer);

	Animation animation = createAnimationFromGLTexId(texid);

	animationGLTexIdSetOwnership(texid, FALSE);

	return animation;

}

Animation createAnimationFromViewportEx(int horWrap, int vertWrap, int smooth, int mipMap) {

	int width = 0;

	int height = 0;

	unsigned char *pixels = NULL;

	if (!imageFromViewport(&width, &height, &pixels)) return createAnimationEmpty();

	return createAnimationFromImageEx(width, height, pixels, horWrap, vertWrap, smooth, mipMap);

}

Animation createAnimationFromViewport()

	{ return createAnimationFromViewportEx(FALSE, FALSE, TRUE, TRUE); }

Animation createAnimation(const char *path)

	{ return createAnimationEx(path, TRUE, FALSE, FALSE); }

void animationDestroy(Animation animation) {

	for(int i = spritesGetCount() - 1; i >= 0; --i) {

		Sprite s = spritesGet(i);

		if (spriteGetAnimation(s) == animation)

			spriteSetNoAnimation(s);

	}

	HeliDrawingState *ss = heliDrawingGetState();

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

		if (ss->fillTexture.animation == animation) ss->fillTexture.animation = NULL;

		if (ss->strokeTexture.animation == animation) ss->strokeTexture.animation = NULL;

	}

	*(animation->prev ? &animation->prev->next : &first) = animation->next;

	*(animation->next ? &animation->next->prev : &last ) = animation->prev;

	heliArrayDestroy(&animation->frames);

	heliObjectUnregister(animation);

	free(animation);

}

Animation animationCloneEx(Animation animation, int from, int to) {

	Animation a = createAnimationEmpty();

	animationInsertEx(a, 0, animation, from, to);

	animationSetFps(a, animationGetFps(animation));

	animationSetPos(a, animationGetPos(animation));

	if (animationIsPlaying(animation)) animationPlay(a); else animationPause(a);

	return a;

}

Animation animationClone(Animation animation)

	{ return animationCloneEx(animation, 0, animationGetFramesCount(animation)); }

unsigned int animationGetFrameGLTexId(Animation animation, int frame) {

	int count = animationGetFramesCount(animation);

	if (frame < 0 || frame >= count) return 0;

	HeliTexture *texture = (HeliTexture*)animation->frames.items[frame].value;

	return texture->id;

}

unsigned int animationGetGLTexId(Animation animation)

	{ return animationGetFrameGLTexId(animation, animationGetFrame(animation)); }

int animationGetFramesCount(Animation animation)

	{ return animation->frames.count; }

void animationInsertEx(Animation animation, int index, Animation other, int start, int count) {

	int dcnt = animationGetFramesCount(animation);

	int scnt = animationGetFramesCount(other);

	int i0 = start;

	int i1 = i0 + count;

	if (i0 < 0) i0 = 0;

	if (i1 > scnt) i1 = scnt;

	if (index < 0 || index > dcnt) index = dcnt;

	for(int i = i0; i < i1; ++i, ++index) {

		HeliTexture *texture = (HeliTexture*)other->frames.items[i].value;

		++texture->refcount;

		heliArrayInsert(&animation->frames, index, texture, (HeliFreeCallback)&unrefTexture);

	}

}

void animationInsert(Animation animation, int index, Animation other)

	{ animationInsertEx(animation, index, other, 0, animationGetFramesCount(other)); }

void animationRemove(Animation animation, int start, int count) {

	int cnt = animationGetFramesCount(animation);

	int i0 = start;

	int i1 = i0 + count;

	if (i0 < 0) i0 = 0;

	if (i1 > cnt) i1 = cnt;

	for(int i = i1 - 1; i >= i0; --i)

		heliArrayRemove(&animation->frames, i);

	heliAnimationFixPos(animation);

}

void animationClear(Animation animation)

	{ animationRemove(animation, 0, animationGetFramesCount(animation)); }

double animationGetFps(Animation animation)

	{ return animation->fps; }

void animationSetFps(Animation animation, double fps) {

	animation->fps = !(fps > HELI_MIN_FPS) ? HELI_MIN_FPS

	               : !(fps > HELI_MAX_FPS) ? HELI_MAX_FPS : fps;

}

int animationIsPlaying(Animation animation)

	{ return animation->playing; }

void animationPlay(Animation animation)

	{ animation->playing = TRUE; }

void animationPause(Animation animation)

	{ animation->playing = FALSE; }

void animationAddTime(Animation animation, double time) {

	int cnt = animationGetFramesCount(animation);

	if (cnt <= 0) return;

	double t = animation->fps * time;

	if (animation->loop) {

		t /= cnt; t -= floor(t); t *= cnt;

		animation->pos += t;

		if (animation->pos > cnt) animation->pos -= cnt;

	} else {

		animation->pos += t;

	}

	heliAnimationFixPos(animation);

}

int animationGetLoop(Animation animation)

	{ return animation->loop; }

void animationSetLoop(Animation animation, int loop)

	{ animation->loop = loop != FALSE; }

double animationGetPos(Animation animation)

	{ return animation->pos; }

void animationSetPos(Animation animation, double pos)

	{ animation->pos = pos; heliAnimationFixPos(animation); }

int animationGetFrame(Animation animation) {

	int cnt = animationGetFramesCount(animation);

	int i = floor(animation->pos + HELI_PRECISION);

	if (i >= cnt) i = cnt - 1;

	if (i < 0) i = 0;

	return i;

}

void animationSetFrame(Animation animation, int frame)

	{ animationSetPos(animation, frame); }

void animationNextFrame(Animation animation)

	{ animationAddTime(animation, 1/animationGetFps(animation)); }

void heliAnimationUpdate(double dt) {

	for(Animation animation = first; animation; animation = animation->next)

		if (animationIsPlaying(animation))

			animationAddTime(animation, dt);

}

void heliAnimationFinish() {

	assert(!cache.count);

	heliArrayDestroy(&cache);

}