#include <common.h>
#include <game.h>

struct SpriteSwapper {
	u32 id;			// 0x00
	u32 settings;	// 0x04
	u16 name;		// 0x08
	u8 _0A[6];		// 0x0A
	u8 _10[0x9C];	// 0x10
	float x;		// 0xAC
	float y;		// 0xB0
	float z;		// 0xB4
	u8 _B8[0x318];	// 0xB8
	// Any variables you add to the class go here; starting at offset 0x3D0
	u64 eventFlag;
	u64 alteventFlag;
	u8 alteventState;
	u8 alteventTrue;
	u16 firstType;
	u16 secondType;
	u8 lastEvState;
	u32 spawnedActor;
	u16 spawn;
	u16 spawned;
	u8 direction;
	Vec speed;
	S16Vec rot;
};

struct EventTable_t {
	u64 events;
};




extern EventTable_t *EventTable;
extern "C" dStageActor_c *CreateActor(u16 classID, int settings, Vec pos, char rot, char layer);
extern "C" dStageActor_c *Actor_SearchByID(u32 actorID);

void SpriteSwapper_Update(SpriteSwapper *self);
void SpriteSwapper_CopyAndDestroy(SpriteSwapper *self, dStageActor_c *actor);
void SpriteSwapper_SpawnActor(SpriteSwapper *self, u16 newActorName);

#define ACTIVATE	1
#define DEACTIVATE	0




bool SpriteSwapper_Create(SpriteSwapper *self) {
	OSReport("I exist, dammit!");

	char eventNum	= (self->settings >> 28)	& 0xF;
	char alteventNum	= (self->settings >> 12)	& 0xF;
	OSReport("Event to activate: %d", eventNum);
	OSReport("AltEvent to activate: %d", alteventNum);

	self->eventFlag = (u64)1 << (eventNum - 1);
	self->alteventFlag = (u64)1 << (alteventNum - 1);
	self->spawnedActor = 0;
	self->firstType = (self->settings >> 16) & 0xFFF;
	self->secondType = self->settings & 0xFFF;

	self->alteventState = 0;
	if (alteventNum > 0)
		self->alteventTrue = 1;
	else
		self->alteventTrue = 0;
				
	Vec pos;
	pos.x = self->x;
	pos.y = self->y;
	pos.z = self->z;

	OSReport("Spawning first sprite.");

	dStageActor_c *spawned = CreateActor(self->firstType, 0, pos, 0, 0);
	self->spawnedActor = spawned->id;
	self->spawned = self->firstType;
	self->spawn = 0;

	OSReport("Spawned %d.", self->spawnedActor);

	SpriteSwapper_Update(self);
	
	return true;
}

bool SpriteSwapper_Execute(SpriteSwapper *self) {
	SpriteSwapper_Update(self);
	return true;
}



void SpriteSwapper_CopyAndDestroy(SpriteSwapper *self) {

	dStageActor_c *spawned = Actor_SearchByID(self->spawnedActor);
	if (spawned != 0) {
		OSReport("It's still alive.");
		self->x = spawned->pos.x;
		self->y = spawned->pos.y;
		self->z = spawned->pos.z;
		self->direction = spawned->direction;
		self->speed = spawned->speed;
		self->rot = spawned->rot;
		spawned->Delete();
	
		self->spawnedActor = 0;
		OSReport("Now it's deleted.");
	}
	
	else {
		OSReport("Is dead, turn it off.... forever.");
		self->spawn = 0;
	}
}


void SpriteSwapper_SpawnActor(SpriteSwapper *self, u16 newActorName) {

	Vec pos;
	pos.x = self->x;
	pos.y = self->y;
	pos.z = self->z;

	OSReport("Making sprite.");
	dStageActor_c *spawner = CreateActor(newActorName, 0, pos, 0, 0);
	self->spawnedActor = spawner->id;
//	spawner->direction = self->direction;
//	spawner->speed = self->speed;

//	OSReport("Direction is %d.", spawner->direction);
//	OSReport("Initial Rotation is %x %x.", spawner->rot.y, spawner->_106.y);
//	if (spawner->direction == 0) {
//		spawner->rot.y = 0xF556 + spawner->rot.y; }
//	else {
//		spawner->rot.y = 0xC000; }
//	OSReport("Current Rotation is %x %x.", spawner->rot.y, spawner->_106.y);



//Direction is 1.
//Initial Rotation is ffffd556
//
// Direction is 0.
//Initial Rotation is ffffc000
//
//Direction is 0
//Initial Rotation is ffffd556

		
		
//	spawner->rot = self->rot;
	OSReport("Spawned %d.", self->spawnedActor);
	
}


void SpriteSwapper_Update(SpriteSwapper *self) {
				
	if (self->spawn != 0)
	{
		OSReport("Spawning %d.", self->spawn);
		SpriteSwapper_SpawnActor(self, self->spawn);
		self->spawned = self->spawn;
		self->spawn = 0;
		return;
	}

	// Sprites alternate when event a is turned on or off.
	if (self->alteventTrue == 0)
	{
		OSReport("Single Event Type.");
		if (EventTable->events & self->eventFlag)
		{		
			OSReport("Spawning Event is on.");
			if (self->spawned == self->secondType)
			{
				OSReport("Second sprite already there.");
				return;
			}
				
			OSReport("Event turned on.");
			
			self->spawn = self->secondType;
			SpriteSwapper_CopyAndDestroy(self);
		}
		else
		{
			OSReport("Spawning Event is off.");
			if (self->spawned == self->firstType)
			{
				OSReport("First sprite already there.");
				return;
			}
				
			OSReport("Event turned off.");

			self->spawn = self->firstType;
			SpriteSwapper_CopyAndDestroy(self);
		}
	}
	
	// Sprites alternate when event a or b is turned on.
	else
	{
		OSReport("Dual Event Type. EventState is %d.", self->alteventState);
		if (EventTable->events & self->eventFlag)
		{		
			OSReport("First Event on, spawning is alteventState is 0.");
			if (self->alteventState == 0)
			{
				if (self->spawned == self->secondType)
				{
					OSReport("Second sprite already there.");
					return;
				}
					
				OSReport("Event turned on.");
				
				self->spawn = self->secondType;
				SpriteSwapper_CopyAndDestroy(self);

				EventTable->events = EventTable->events & ~self->alteventFlag;
				self->alteventState = 1;
			}
		}

		if (EventTable->events & self->alteventFlag)
		{
			OSReport("Second Event on, spawning is alteventState is 1.");
			if (self->alteventState == 1)
			{
				if (self->spawned == self->firstType)
				{
					OSReport("First sprite already there.");
					return;
				}
					
				OSReport("Alt Event turned on.");
				
				self->spawn = self->firstType;
				SpriteSwapper_CopyAndDestroy(self);
				
				EventTable->events = EventTable->events & ~self->eventFlag;
				self->alteventState = 0;
			}
		}

	}

}