#include "private.h"
#include "group.h"
#include "window.h"

struct _Group {
	HeliArray sprites;
	HeliArray spritesSorted;
};


Group createGroup() {
	if (!heliInitialized) return NULL;
	Group g = calloc(1, sizeof(*g));
	heliObjectRegister(g, (HeliFreeCallback)&groupDestroy);
	return g;
}

Group createEdgesGroupEx(double x1, double y1, double x2, double y2, double borderWidth, int massLevel) {
	if (!heliInitialized) return NULL;
	if (x2 < x1) { double x = x2; x2 = x1; x1 = x; }
	if (y2 < y1) { double y = y2; y2 = y1; y1 = y; }
	if (borderWidth < 0.1) borderWidth = 0.1;
	
	double b = borderWidth;
	double w = x2 - x1 + b*2;
	double h = y2 - y1 + b*2;
	x1 -= b;
	y1 -= b;
	
	Group g = createGroup();
	groupAdd(g, createSprite(x1 + w/2, y1 + b/2, w, b));
	groupAdd(g, createSprite(x1 + w/2, y2 + b/2, w, b));
	groupAdd(g, createSprite(x1 + b/2, y1 + h/2, b, h));
	groupAdd(g, createSprite(x2 + b/2, y1 + h/2, b, h));
	groupSetMassLevelEach(g, massLevel);
	return g;
}

Group createEdgesGroup()
	{ return createEdgesGroupEx(0, 0, windowGetWidth(), windowGetHeight(), windowGetHeight(), 100); }


void groupDestroy(Group group) {
	groupClear(group);
	heliArrayDestroy(&group->sprites);
	heliArrayDestroy(&group->spritesSorted);
	heliObjectUnregister(group);
	free(group);
}

void groupDestroyEx(Group group, int destroySprites) {
	groupClearEx(group, destroySprites);
	groupDestroy(group);
}

void groupAdd(Group group, Sprite sprite) {
	if (!sprite) return;
	if (groupContains(group, sprite)) return;
	heliArrayInsert(&group->sprites, -1, sprite, NULL);
	heliArrayInsert(&group->spritesSorted, -1, sprite, NULL);
	heliArrayInsert(heliSpriteGetGroups(sprite), -1, group, NULL);
}

void groupRemove(Group group, Sprite sprite) {
	for(int i = group->sprites.count-1; i >= 0; --i)
		if (group->sprites.items[i].value == sprite)
			heliArrayRemove(&group->sprites, i);
	for(int i = group->spritesSorted.count-1; i >= 0; --i)
		if (group->spritesSorted.items[i].value == sprite)
			heliArrayRemove(&group->spritesSorted, i);
	HeliArray *groups = heliSpriteGetGroups(sprite);
	for(int i = groups->count-1; i >= 0; --i)
		if (groups->items[i].value == group)
			heliArrayRemove(groups, i);
}

void groupClearEx(Group group, int destroySprites) {
	while(groupGetCount(group) > 0) {
		Sprite s = groupGet(group, 0);
		groupRemove(group, s);
		if (destroySprites) spriteDestroy(s);
	}
}

void groupClear(Group group)
	{ groupClearEx(group, FALSE); }
void groupDestroyEach(Group group)
	{ groupClearEx(group, TRUE); }

int groupContains(Group group, Sprite sprite) {
	for(int i = group->sprites.count-1; i >= 0; --i)
		if (group->sprites.items[i].value == sprite)
			return TRUE;
	return FALSE;
}

int groupGetCount(Group group)
	{ return group->sprites.count; }
Sprite groupGet(Group group, int i)
	{ return (Sprite)heliArrayGetValue(&group->sprites, i); }


Sprite groupSpriteByPoint(Group group, double x, double y, int onlyVisible) {
	heliSpriteSort(&group->spritesSorted);
	for(int i = group->spritesSorted.count - 1; i >= 0; --i) {
		Sprite s = (Sprite)(group->spritesSorted.items[i].value);
		if ((!onlyVisible || spriteGetVisible(s)) && spriteIsPointInside(s, x, y)) return s;
	}
	return NULL;
}


void groupDraw(Group group) {
	heliSpriteSort(&group->spritesSorted);
	for(int i = 0; i < group->spritesSorted.count; ++i) {
		Sprite s = (Sprite)(group->spritesSorted.items[i].value);
		if (spriteGetVisible(s)) heliSpriteDraw(s);
	}
	for(int i = 0; i < group->spritesSorted.count; ++i) {
		Sprite s = (Sprite)(group->spritesSorted.items[i].value);
		if (spriteGetDebug(s)) heliSpriteDrawDebug(s);
	}
}


int groupOverlap(Group group, Sprite sprite) {
	for(int i = 0; i < groupGetCount(group); ++i)
		if (spriteOverlap(groupGet(group, i), sprite))
			return TRUE;
	return FALSE;
}

int groupCollide(Group group, Sprite sprite) {
	int result = FALSE;
	for(int j = 0; j < 10; ++j) {
		int actualCollision = FALSE;
		Sprite bestSprite = NULL;
		HeliCollisionInfo bestInfo = {};
		for(int i = 0; i < groupGetCount(group); ++i) {
			Sprite s = groupGet(group, i);
			HeliCollisionInfo info = {};
			if (heliSpriteCollisionCheck(s, sprite, &info)) {
				if (info.actualCollision) actualCollision = TRUE;
				if (!bestSprite || bestInfo.distance <= info.distance) {
					bestSprite = s;
					memcpy(&bestInfo, &info, sizeof(bestInfo));
				}
			}
		}
		if (!bestSprite) break;
		heliSpriteCollisionApply(bestSprite, sprite, &bestInfo);
		if (!actualCollision) break;
		result = TRUE;
	}
	return result;
}

int groupOverlapGroup(Group a, Group b) {
	for(int i = 0; i < groupGetCount(b); ++i)
		if (groupOverlap(a, groupGet(b, i)))
			return TRUE;
	return FALSE;
}

int groupCollideGroup(Group a, Group b) {
	int result = FALSE;
	for(int i = 0; i < groupGetCount(b); ++i)
		if (groupCollide(a, groupGet(b, i)))
			result = TRUE;
	return result;
}

int groupOverlapBetween(Group group) {
	for(int i = 0; i < groupGetCount(group); ++i)
		for(int j = i+1; j < groupGetCount(group); ++j)
			if (spriteOverlap(groupGet(group, i), groupGet(group, j)))
				return TRUE;
	return FALSE;
}

int groupCollideBetween(Group group) {
	int result = FALSE;
	for(int i = 0; i < groupGetCount(group); ++i)
		for(int j = i+1; j < groupGetCount(group); ++j)
			if (spriteCollide(groupGet(group, i), groupGet(group, j)))
				result = TRUE;
	return result;
}

void groupResetTouch(Group group) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteResetTouch(groupGet(group, i));
}


double groupGetMinDepth(Group group) {
	if (groupGetCount(group) <= 0) return 0;
	double md = spriteGetDepth(groupGet(group, 0));
	for(int i = 1; i < groupGetCount(group); ++i) {
		double d = spriteGetDepth(groupGet(group, i));
		if (d < md) md = d;
	}
	return md;
}

double groupGetMaxDepth(Group group) {
	if (groupGetCount(group) <= 0) return 0;
	double md = spriteGetDepth(groupGet(group, 0));
	for(int i = 1; i < groupGetCount(group); ++i) {
		double d = spriteGetDepth(groupGet(group, i));
		if (d > md) md = d;
	}
	return md;
}


static void foreachInt(Group group, int value, HeliSpriteEashInt func)
	{ for(int i = 0; i < groupGetCount(group); ++i) func(groupGet(group, i), value); }
static void foreachUInt(Group group, unsigned int value, HeliSpriteEashUInt func)
	{ for(int i = 0; i < groupGetCount(group); ++i) func(groupGet(group, i), value); }
static void foreachDouble(Group group, double value, HeliSpriteEashDouble func)
	{ for(int i = 0; i < groupGetCount(group); ++i) func(groupGet(group, i), value); }


void groupDestroyTimerEach(Group group, double lifetime)
	{ for(int i = groupGetCount(group) - 1; i >= 0; --i) spriteDestroyTimer(groupGet(group, i), lifetime); }

void groupSetVisibleEach(Group group, int visible)
	{ foreachInt(group, visible, &spriteSetVisible); }
void groupSetFrozenEach(Group group, int frozen)
	{ foreachInt(group, frozen, &spriteSetFrozen); }
void groupSetDebugEach(Group group, int debug)
	{ foreachInt(group, debug, &spriteSetDebug); }
void groupSetWidthEach(Group group, double width)
	{ foreachDouble(group, width, &spriteSetWidth); }
void groupSetHeightEach(Group group, double height)
	{ foreachDouble(group, height, &spriteSetHeight); }
void groupSetDepthEach(Group group, double depth)
	{ foreachDouble(group, depth, &spriteSetDepth); }
void groupSetXEach(Group group, double x)
	{ foreachDouble(group, x, &spriteSetX); }
void groupSetYEach(Group group, double y)
	{ foreachDouble(group, y, &spriteSetY); }
void groupSetVelocityXEach(Group group, double x)
	{ foreachDouble(group, x, &spriteSetVelocityX); }
void groupSetVelocityYEach(Group group, double y)
	{ foreachDouble(group, y, &spriteSetVelocityY); }
void groupSetAccelerationXEach(Group group, double x)
	{ foreachDouble(group, x, &spriteSetAccelerationX); }
void groupSetAccelerationYEach(Group group, double y)
	{ foreachDouble(group, y, &spriteSetAccelerationY); }
void groupSetRotateToDirectionEach(Group group, int rotateToDirection)
	{ foreachInt(group, rotateToDirection, &spriteSetRotateToDirection); }
void groupSetRotationEach(Group group, double rotation)
	{ foreachDouble(group, rotation, &spriteSetRotation); }
void groupSetRotationSpeedEach(Group group, double rotationSpeed)
	{ foreachDouble(group, rotationSpeed, &spriteSetRotationSpeed); }
void groupSetScaleEach(Group group, double scale)
	{ foreachDouble(group, scale, &spriteSetScale); }
void groupSetMirrorXEach(Group group, int mirrorX)
	{ foreachInt(group, mirrorX, &spriteSetMirrorX); }
void groupSetMirrorYEach(Group group, int mirrorY)
	{ foreachInt(group, mirrorY, &spriteSetMirrorY); }
void groupSetShapeColorEach(Group group, unsigned int colorCode)
	{ foreachUInt(group, colorCode, &spriteSetShapeColor); }
void groupSetTintColorEach(Group group, unsigned int colorCode)
	{ foreachUInt(group, colorCode, &spriteSetTintColor); }
void groupSetUserTagEach(Group group, int tag)
	{ foreachInt(group, tag, &spriteSetUserTag); }

void groupSetBouncinessEach(Group group, double bounciness)
	{ foreachDouble(group, bounciness, &spriteSetBounciness); }
void groupSetBouncinessThresholdEach(Group group, double bouncinessThreshold)
	{ foreachDouble(group, bouncinessThreshold, &spriteSetBouncinessThreshold); }
void groupSetFrictionEach(Group group, double friction)
	{ foreachDouble(group, friction, &spriteSetFriction); }
void groupSetAirFrictionEach(Group group, double friction)
	{ foreachDouble(group, friction, &spriteSetAirFriction); }
void groupSetMassLevelEach(Group group, int massLevel)
	{ foreachInt(group, massLevel, &spriteSetMassLevel); }
void groupSetColliderSensitiveDistanceEach(Group group, double distance)
	{ foreachDouble(group, distance, &spriteSetColliderSensitiveDistance); }


void groupSetAnimationEach(Group group, Animation animation) {
	for(int i = groupGetCount(group) - 1; i >= 0 ; --i)
		spriteSetAnimation(groupGet(group, i), animation);
}

void groupSetNoAnimationEach(Group group) {
	for(int i = groupGetCount(group) - 1; i >= 0 ; --i)
		spriteSetNoAnimation(groupGet(group, i));
}

void groupPointToEach(Group group, double x, double y) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spritePointTo(groupGet(group, i), x, y);
}

void groupSetSpeedAndDirectionEach(Group group, double speed, double angle) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteSetSpeedAndDirection(groupGet(group, i), speed, angle);
}

void groupSetXYEach(Group group, double x, double y) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteSetXY(groupGet(group, i), x, y);
}
void groupSetVelocityEach(Group group, double x, double y) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteSetVelocityXY(groupGet(group, i), x, y);
}
void groupSetAccelerationEach(Group group, double x, double y) {
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteSetAccelerationXY(groupGet(group, i), x, y);
}


void groupSetUserTextEach(Group group, const char *text) {
	for(int i = groupGetCount(group) - 1; i >= 0 ; --i)
		spriteSetUserText(groupGet(group, i), text);
}

void groupSetUserDataEach(Group group, void *data) {
	for(int i = groupGetCount(group) - 1; i >= 0 ; --i)
		spriteSetUserData(groupGet(group, i), data);
}

void groupSetDestroyEach(Group group, SpriteCallback destroy) {
	for(int i = groupGetCount(group) - 1; i >= 0 ; --i)
		spriteSetDestroy(groupGet(group, i), destroy);
}


void groupSetColliderEach(Group group, Collider type, double xOffset, double yOffset, double rotationOffset)
	{ groupSetColliderEachEx(group, type, xOffset, yOffset, rotationOffset, -1, -1, -1); }
void groupSetColliderCircleEach(Group group, double xOffset, double yOffset, double radius)
	{ groupSetColliderEachEx(group, COLLIDER_CIRCLE, xOffset, yOffset, 0, 0, 0, radius); }
void groupSetColliderRectangleEach(
	Group group, double xOffset, double yOffset, double rotationOffset,
	double width, double height, double cornersRadius )
{
	groupSetColliderEachEx(
		group, COLLIDER_RECTANGLE,
		xOffset, yOffset, rotationOffset,
		width, height, cornersRadius);
}
void groupSetColliderEachEx(
	Group group, Collider type,
	double xOffset, double yOffset, double rotationOffset,
	double width, double height, double radius)
{
	for(int i = 0; i < groupGetCount(group); ++i)
		spriteSetColliderEx(
			groupGet(group, i), type,
			xOffset, yOffset, rotationOffset,
			width, height, radius );
}