#include <glib.h></glib.h>

#include <cairo.h></cairo.h>

#include "private.h"

#include "world.h"

#include "sprite.h"

static HeliArray cache;

static cairo_status_t read(void *closure, unsigned char *data, unsigned int length) {

	return fread(data, length, 1, (FILE*)closure)

		 ? CAIRO_STATUS_SUCCESS : CAIRO_STATUS_READ_ERROR;

}

static cairo_surface_t* loadFrame(const char *path) {

	if (!heliStringEndsWithLowcase(path, ".png"))

		return NULL;

	FILE *f = fopen(path, "rb");

	if (f) {

		cairo_surface_t *frame = cairo_image_surface_create_from_png_stream(&read, f);

		fclose(f);

		if (!frame)

			fprintf(stderr, "helianthus: cannot load PNG content form file: %s\n", path);

		return frame;

	}

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

	return NULL;

}

static HeliAnimationInstance* load(const char *path) {

	HeliAnimationInstance *a = calloc(1, sizeof(*a));

	a->path = heliStringCopy(path);

	GDir *dir = g_dir_open(path, 0, NULL);

	if (dir) {

		while(TRUE) {

			const char* name = g_dir_read_name(dir);

			if (!name) break;

			char *p = heliStringConcat3(path, "/", name);

			cairo_surface_t *frame = loadFrame(p);

			free(p);

			if (frame) heliArrayInsert(&a->frames, -1, frame, (HeliFreeCallback)&cairo_surface_destroy);

		}

	} else {

		cairo_surface_t *frame = loadFrame(path);

		if (frame) {

			heliArrayInsert(&a->frames, -1, frame, (HeliFreeCallback)&cairo_surface_destroy);

		} else {

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

		}

	}

	return a;

}

static void unload(HeliAnimationInstance *a) {

	assert(!a->refcount);

	free(a->path);

	heliArrayDestroy(&a->frames);

	free(a);

}

Animation createAnimation(const char *path) {

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

	if (!item) item = heliStringmapAdd(&cache, path, load(path), (HeliFreeCallback)&unload);

	HeliAnimationInstance *a = (HeliAnimationInstance*)item->value;

	++a->refcount;

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

	animation->instance = a;

	++animation->refcount;

	return animation;

}

void animationDestroy(Animation animation) {

	if (--animation->refcount <= 0) {

		if (--animation->instance->refcount <= 0)

			heliStringmapRemove(&cache, animation->instance->path);

		free(animation);

	}

}

void heliAnimationFinish()

	{ heliArrayDestroy(&cache); }