#ifndef HELI_PRIVATE_H

#define HELI_PRIVATE_H

#include <assert.h></assert.h>

#include <string.h></string.h>

#include <stdlib.h></stdlib.h>

#include <stdio.h></stdio.h>

#include <ctype.h></ctype.h>

#include <math.h></math.h>

#define GL_GLEXT_PROTOTYPES

#include <gl gl.h=""></gl>

#include <gl glext.h=""></gl>

#include "common.h"

#include "animation.h"

#include "framebuffer.h"

#include "sprite.h"

#include "font.h"

// globals

#define HELI_PRECISION 1e-6

#define HELI_PRECISION_SQR 1e-12

#define HELI_MIN_FPS 1

#define HELI_MAX_FPS 100

#define HELI_DEFAULT_FPS 24

// blobs

extern char heliBlobDefaultFont[] asm("heliBlobDefaultFont");

extern int heliBlobDefaultFontSize asm("heliBlobDefaultFontSize");

extern char heliBlobUnicodeFont[] asm("heliBlobUnicodeFont");

extern int heliBlobUnicodeFontSize asm("heliBlobUnicodeFontSize");

// string

char* heliStringCopy(const char *x);

char* heliStringCopyLower(const char *x);

char* heliStringConcat(const char *a, const char *b);

char* heliStringConcat3(const char *a, const char *b, const char *c);

int heliStringCompareCi(const char *a, const char *b);

int heliStringEndsWithLowcase(const char *s, const char *tail);

void heliStringLower(char *x);

// common

void heliColorToDouble(unsigned int code, double *rgba);

// pointer array

typedef void (*HeliFreeCallback)(void*);

typedef void* (*HeliCloneCallback)(const void*);

typedef int (*HeliCompareCallback)(const void*, const void*);

typedef struct _HeliPair {

	void *key;

	void *value;

	HeliFreeCallback freeKey;

	HeliFreeCallback freeValue;

} HeliPair;

typedef struct _HeliArray {

	HeliPair *items;

	int count;

	int allocated;

} HeliArray;

void heliPairInit(HeliPair *p);

void heliPairDestroy(HeliPair *p);

void heliArrayInit(HeliArray *a);

void heliArrayClear(HeliArray *a);

void heliArrayDestroy(HeliArray *a);

HeliPair* heliArrayGet(HeliArray *a, int i);

void* heliArrayGetKey(HeliArray *a, int i);

void* heliArrayGetValue(HeliArray *a, int i);

HeliPair* heliArrayInsert(HeliArray *a, int i, void *v, HeliFreeCallback fv);

HeliPair* heliArrayInsertPair(HeliArray *a, int i, void *k, HeliFreeCallback fk, void *v, HeliFreeCallback fv);

void heliArrayRemove(HeliArray *a, int i);

HeliPair* heliMapFind(HeliArray *a, const void *k, HeliCompareCallback cmp, int *gtOrEqIndex);

HeliPair* heliMapGet(HeliArray *a, const void *k, HeliCompareCallback cmp);

HeliPair* heliMapAdd(

	HeliArray *a, const void *k, HeliCompareCallback cmp,

	HeliCloneCallback ck, HeliFreeCallback fk,

	void *v, HeliFreeCallback fv );

int heliMapRemove(HeliArray *a, const void *k, HeliCompareCallback cmp);

HeliPair* heliUIntFind(HeliArray *a, size_t k, int *gtOrEqIndex);

HeliPair* heliUIntGet(HeliArray *a, size_t k);

HeliPair* heliUIntAdd(HeliArray *a, size_t k, void *v, HeliFreeCallback fv);

int heliUIntRemove(HeliArray *a, size_t k);

HeliPair* heliStringmapFind(HeliArray *a, const char *k, int *gtOrEqIndex);

HeliPair* heliStringmapGet(HeliArray *a, const char *k);

HeliPair* heliStringmapAdd(HeliArray *a, const char *k, void *v, HeliFreeCallback fv);

int heliStringmapRemove(HeliArray *a, const char *k);

// geometry

void heliMatrix4Identity(double *r);

void heliMatrix4Translation(double *r, double x, double y, double z);

void heliMatrix4Scale(double *r, double x, double y, double z);

void heliMatrix4RotationZ(double *r, double a);

void heliMatrix4MultVec(double *r, const double *m, const double *v);

void heliMatrix4Mult(double *r, const double *a, const double *b);

int heliMatrix4Invert(double *r, const double *m);

// gl

typedef struct _HeliGLClipPlaneState {

	int enabled;

	double equation[4];

} HeliGLClipPlaneState;

typedef struct _HeliGLCommonState {

	unsigned int flags;

	double modelviewMatrix[16];

	double projectionMatrix[16];

	double clearColor[4];

	int viewport[4];

	unsigned int framebuffer_read_id;

	unsigned int framebuffer_draw_id;

	HeliGLClipPlaneState clipPlanes[4];

} HeliGLCommonState;

typedef void (APIENTRY *HeliGLBlendFuncSeparatePtr)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);

typedef void (APIENTRY *HeliGLStencilOpSeparatePtr)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);

typedef void (APIENTRY *HeliGLTexImage2DMultisamplePtr)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

typedef void (APIENTRY *HeliGLGenFramebuffersPtr)(GLsizei n, GLuint *framebuffers);

typedef void (APIENTRY *HeliGLDeleteFramebuffersPtr)(GLsizei n, const GLuint *framebuffers);

typedef void (APIENTRY *HeliGLBindFramebufferPtr)(GLenum target, GLuint framebuffer);

typedef void (APIENTRY *HeliGLBlitFramebufferPtr)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

typedef void (APIENTRY *HeliGLFramebufferRenderbufferPtr)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

typedef void (APIENTRY *HeliGLFramebufferTexture2DPtr)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

typedef GLenum (APIENTRY *HeliGLCheckFramebufferStatusPtr)(GLenum target);

typedef void (APIENTRY *HeliGLGenRenderbuffersPtr)(GLsizei n, GLuint *renderbuffers);

typedef void (APIENTRY *HeliGLDeleteRenderbuffersPtr)(GLsizei n, const GLuint *renderbuffers);

typedef void (APIENTRY *HeliGLBindRenderbufferPtr)(GLenum target, GLuint renderbuffer);

typedef void (APIENTRY *HeliGLRenderbufferStoragePtr)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

typedef void (APIENTRY *HeliGLRenderbufferStorageMultisamplePtr)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

extern HeliGLBlendFuncSeparatePtr       heliGLBlendFuncSeparatePtr;

extern HeliGLStencilOpSeparatePtr       heliGLStencilOpSeparatePtr;

extern HeliGLTexImage2DMultisamplePtr   heliGLTexImage2DMultisamplePtr;

extern HeliGLGenFramebuffersPtr         heliGLGenFramebuffersPtr;

extern HeliGLDeleteFramebuffersPtr      heliGLDeleteFramebuffersPtr;

extern HeliGLBindFramebufferPtr         heliGLBindFramebufferPtr;

extern HeliGLBlitFramebufferPtr         heliGLBlitFramebufferPtr;

extern HeliGLFramebufferRenderbufferPtr heliGLFramebufferRenderbufferPtr;

extern HeliGLFramebufferTexture2DPtr    heliGLFramebufferTexture2DPtr;

extern HeliGLCheckFramebufferStatusPtr  heliGLCheckFramebufferStatusPtr;

extern HeliGLGenRenderbuffersPtr        heliGLGenRenderbuffersPtr;

extern HeliGLDeleteRenderbuffersPtr     heliGLDeleteRenderbuffersPtr;

extern HeliGLBindRenderbufferPtr        heliGLBindRenderbufferPtr;

extern HeliGLRenderbufferStoragePtr     heliGLRenderbufferStoragePtr;

extern HeliGLRenderbufferStorageMultisamplePtr heliGLRenderbufferStorageMultisamplePtr;

extern unsigned int heliGLWindowFramebufferReadId;

extern unsigned int heliGLWindowFramebufferDrawId;

double heliGLGetAAResolution();

int heliGLIsIntegerClipping();

int heliGLBackTransform(double *x, double *y);

void heliGLGetCommonState(HeliGLCommonState *state, unsigned int flags);

void heliGLSetCommonState(const HeliGLCommonState *state);

// all objects

extern int heliInitialized;

extern HeliArray heliObjectsSet;

void heliObjectRegister(void *o, HeliFreeCallback fo);

void heliObjectUnregister(void *o);

// drawing

typedef struct _HeliTextureState {

	double color[4];

	Animation animation;

	int fixed;

	double x, y, width, height;

} HeliTextureState;

typedef struct _HeliDrawingState {

	unsigned int flags;

	double fillColor[4];

	double strokeColor[4];

	double strokeWidth;

	HAlign horAlign;

	VAlign vertAlign;

	double fontSize;

	Font font;

	HeliTextureState fillTexture;

	HeliTextureState strokeTexture;

	HeliGLCommonState glState;

} HeliDrawingState;

HeliArray heliDrawingFramebuffersToFlush;

HeliDrawingState *heliDrawingGetState();

HeliDrawingState *heliDrawingGetStateStack();

void heliDrawingApplyTexture(double *color, HeliTextureState *state);

void heliDrawingResetTexture();

void heliFillRectSimple(double x0, double y0, double x1, double y1, double aaBorder);

void heliFillCircleSimple(double x, double y, double r, double aaBorder);

void heliDrawingClearFrame();

void heliDrawingPrepareFrame();

void heliDrawingFinish();

// font

void heliFontFinish();

// animation

void heliAnimationUpdate(double dt);

void heliAnimationFinish();

// collider

typedef struct _HeliCollider {

	Collider type;

	double x;

	double y;

	double radius;

	double width;

	double height;

	double rotation;

	double bounciness;

	double bouncinessThreshold;

} HeliCollider;

typedef struct _HeliCollisionInfo {

	int actualCollision;

	double distance;

	double dx, dy;

	double vx, vy;

	double ax, ay;

} HeliCollisionInfo;

int heliCheckCollision(

	HeliCollider *a, HeliCollider *b,

	HeliCollisionInfo *info,

	double distance );

int heliPointCollision(HeliCollider *c, double x, double y);

// sprite

typedef void (*HeliSpriteEashInt)(Sprite, int);

typedef void (*HeliSpriteEashUInt)(Sprite, unsigned int);

typedef void (*HeliSpriteEashDouble)(Sprite, double);

HeliArray* heliSpriteGetGroups(Sprite sprite);

int heliSpriteCollisionCheck(Sprite a, Sprite b, HeliCollisionInfo *info);

void heliSpriteCollisionApply(Sprite a, Sprite b, HeliCollisionInfo *info);

void heliSpriteDraw(Sprite sprite);

void heliSpriteDrawDebug(Sprite sprite);

void heliSpriteSort(HeliArray *sprites);

void heliSpriteUpdate(double dt);

void heliSpriteFinish();

// sound

void heliSoundUpdate();

void heliSoundFinish();

// world

typedef struct _HeliDialog {

	int shown;

	const char *question;

	char *answer;

	char *passwordText;

	int maxAnswerSize;

	int multiline;

	int password;

	int pos;

	int selPos;

	double scrollX;

	double scrollY;

	int success;

	char newText[4096];	

} HeliDialog;

void heliDialogDraw(HeliDialog *dialog);

// test

void heliDoTests();

#endif