#include "koopatlas/pathmanager.h"
#include "koopatlas/core.h"
#include "koopatlas/hud.h"
#include "koopatlas/player.h"
#include <sfx.h>

void dWMPathManager_c::setup() {
	isMoving = false;
	isJumping = false;
	timer = 0.0;
	currentPath = 0;
	reverseThroughPath = false;

	pathLayer = dScKoopatlas_c::instance->mapData.pathLayer;

	SpammyReport("setting up PathManager\n");
	SaveBlock *save = GetSaveFile()->GetBlock(-1);

	mustComplainToMapCreator = false;

	// Figure out what path node to start at
	if (dScKoopatlas_c::instance->settings & 0x10000000) {
		// Start off from a "Change"
		u8 changeID = dScKoopatlas_c::instance->settings & 0xFF;
		SpammyReport("entering at Change ID %d\n", changeID);
		SpammyReport("Path layer: %p\n", pathLayer);
		SpammyReport("Node count: %d\n", pathLayer->nodeCount);

		bool found = false;

		for (int i = 0; i < pathLayer->nodeCount; i++) {
			dKPNode_s *node = pathLayer->nodes[i];
			SpammyReport("Checking node: %p\n", node);

			if (node->type == dKPNode_s::CHANGE && node->thisID == changeID) {
				found = true;
				currentNode = node;

				SpammyReport("a1 Node: %p\n", node);
				dKPPath_s *exit = node->getAnyExit();
				SpammyReport("a2 Exit: %p\n", exit);
				startMovementTo(exit);
				SpammyReport("a3\n");
				break;
			}
		}

		if (!found) {
			OSReport("Couldn't find target node %d!\n", changeID);
			currentNode = pathLayer->nodes[0];
			mustComplainToMapCreator = true;
		}
		
	} else {
		SpammyReport("saved path node: %d\n", save->current_path_node);
		if (save->current_path_node >= pathLayer->nodeCount) {
			SpammyReport("out of bounds (%d), using node 0\n", pathLayer->nodeCount);
			currentNode = pathLayer->nodes[0];
		} else {
			currentNode = pathLayer->nodes[save->current_path_node];
			SpammyReport("OK %p\n", currentNode);
		}
	}

	// unlock all needed paths
	SpammyReport("Unlocking paths\n");
	for (int i = 0; i < pathLayer->pathCount; i++) {
		dKPPath_s *path = pathLayer->paths[i];

		if (path->unlockType > 0) {
			u32 conds = save->GetLevelCondition(path->unlockLevelNumber[0] - 1, path->unlockLevelNumber[1] - 1);

			if (path->unlockType == 1 && (conds & COND_NORMAL))
				path->isAvailable = true;
			else if (path->unlockType == 2 && (conds & COND_SECRET))
				path->isAvailable = true;
		}
	}
	SpammyReport("done\n");
}


void dWMPathManager_c::execute() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	if (isMoving) {
		moveThroughPath();
	} else {
		if (nowPressed & WPAD_LEFT && canUseExit(currentNode->leftExit))
			startMovementTo(currentNode->leftExit);
		else if (nowPressed & WPAD_RIGHT && canUseExit(currentNode->rightExit))
			startMovementTo(currentNode->rightExit);
		else if (nowPressed & WPAD_UP && canUseExit(currentNode->upExit))
			startMovementTo(currentNode->upExit);
		else if (nowPressed & WPAD_DOWN && canUseExit(currentNode->downExit))
			startMovementTo(currentNode->downExit);
		else if (nowPressed & WPAD_TWO)
			activatePoint();
	}
}


void dWMPathManager_c::startMovementTo(dKPPath_s *path) {
	SpammyReport("moving to path %p\n", path);
	dWMHud_c::instance->hidePointBar();
	SpammyReport("point bar hidden\n");

	SpammyReport("a\n");
	isMoving = true;
	reverseThroughPath = (path->end == currentNode);
	SpammyReport("b\n");

	currentPath = path;
	SpammyReport("c\n");

	// calculate direction of the path
	short deltaX = path->end->x - path->start->x;
	short deltaY = path->end->y - path->start->y;
	SpammyReport("d\n");
	u16 direction = (u16)(atan2(deltaX, deltaY) / ((M_PI * 2) / 65536.0));
	SpammyReport("e\n");

	if (reverseThroughPath) {
	SpammyReport("e2\n");
		direction += 0x8000;
	}

	SpammyReport("f\n");
	daWMPlayer_c *player = daWMPlayer_c::instance;
	SpammyReport("g %p\n", player);


	// Consider adding these as options
	// wall_walk_l = 60,
	// wall_walk_r = 61,

	// hang_walk_l = 65,
	// hang_walk_r = 66,

	SpammyReport("h\n");
	player->rot.y = direction;
	player->hasSound = false;
	player->hasEffect = false;

	switch (path->animation) {

		// Running
		case 0:
			player->startAnimation(run, 2.0, 10.0, 0.0);
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_DIRT;
			break;
		case 1:
			player->startAnimation(run, 2.0, 10.0, 0.0);
			player->hasSound = true;
			player->hasEffect = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_SAND;
			player->effectName = "Wm_mr_foot_sand";
			break;
		case 2:
			player->startAnimation(run, 2.0, 10.0, 0.0);
			player->hasSound = true;
			player->hasEffect = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_SNOW;
			player->effectName = "Wm_mr_foot_snow";
			break;
		case 3:
			player->startAnimation(run, 2.0, 10.0, 0.0);
			player->hasSound = true;
			player->hasEffect = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_WATER;
			player->effectName = "Wm_mr_foot_water";
			break;

		// Jumping
		case 4:
			player->startAnimation(jump, 1.0, 1.0, 0.0);
			MapSoundPlayer(SoundRelatedClass, SE_PLY_JUMP, 1);
			isJumping = true;
			break;
		case 5:
			player->startAnimation(jump, 1.0, 10.0, 0.0);
			MapSoundPlayer(SoundRelatedClass, SE_PLY_JUMP, 1);
			isJumping = true;
			break;
		case 6:
			player->startAnimation(jump, 1.0, 10.0, 0.0);
			MapSoundPlayer(SoundRelatedClass, SE_PLY_JUMP, 1);
			isJumping = true;
			break;
		case 7:
			player->startAnimation(jump, 1.0, 10.0, 0.0);
			MapSoundPlayer(SoundRelatedClass, SE_PLY_JUMP, 1);
			isJumping = true;
			SpawnEffect("Wm_mr_waterwave_out", 0, &player->pos, 0, &player->scale);
			break;

		// Climbing
		case 8:
			player->startAnimation(pea_plant, 1.2, 10.0, 0.0);
			player->rot.y = 0x8000;
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_ROCK_CLIMB;
			break;
		case 9:
			player->startAnimation(tree_climb, 1.2, 10.0, 0.0);
			player->rot.y = 0xC000;
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_ROCK_CLIMB;
			break;
		case 10:
			player->startAnimation(tree_climb, 1.2, 10.0, 0.0);
			player->rot.y = 0x4000;
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_CS_ROCK_CLIMB;
			break;

		// Others
		case 12:
			player->startAnimation(swim_wait, 1.2, 10.0, 0.0);
			player->hasSound = true;
			player->hasEffect = true;
			player->soundName = SE_PLY_SWIM;
			player->effectName = "Wm_mr_waterswim";
			break;
		case 13:
			player->startAnimation(Tjumped, 2.0, 0.0, 0.0);
			break;
		case 14:
			player->startAnimation(b_dash2, 3.0, 10.0, 0.0);
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_DIRT;
			break;
		case 15:
			player->startAnimation(wait, 2.0, 10.0, 0.0);
			player->rot.y = 0x0000;
			MapSoundPlayer(SoundRelatedClass, SE_PLY_DOKAN_IN_OUT, 1);
			break;
		case 16:
			player->startAnimation(wait, 2.0, 10.0, 0.0);
			player->rot.y = 0x8000;			
			MapSoundPlayer(SoundRelatedClass, SE_OBJ_DOOR_OPEN, 1);
			break;
		default:
			OSReport("No animtaion?!");
			player->startAnimation(run, 2.0, 10.0, 0.0);
			player->hasSound = true;
			player->soundName = SE_PLY_FOOTNOTE_DIRT;
			break;
	}
	
	SpammyReport("i\n");
}

void dWMPathManager_c::moveThroughPath() {
	dKPNode_s *from, *to;

	from = reverseThroughPath ? currentPath->end : currentPath->start;
	to = reverseThroughPath ? currentPath->start : currentPath->end;

	Vec move = (Vec){to->x - from->x, to->y - from->y, 0};
	VECNormalize(&move, &move);
	VECScale(&move, &move, 3.0f);

	daWMPlayer_c *player = daWMPlayer_c::instance;

	if (isJumping) {
		float midpoint = (from->y + to->y) / 2;

		keysY[0] = (HermiteKey){ from->y,  	0.0, 	1.0 };
		keysY[1] = (HermiteKey){ midpoint, 	48.0, 	0.8 };
		keysY[2] = (HermiteKey){ to->y, 	0.0, 	1.0 };

		float modY = GetHermiteCurveValue(player->pos.y, keysY, 3);
		OSReport("From: %f to %f, midpoint at: %f, pos at %f, Y mod: %f", from->y, to->y, midpoint, player->pos.y, modY);

		player->pos.x += move.x;
		player->pos.y -= move.y;
	}

	else {
		player->pos.x += move.x;
		player->pos.y -= move.y;
	}

	// Check if we've reached the end yet
	if (
			((move.x > 0) ? (player->pos.x >= to->x) : (player->pos.x <= to->x)) &&
			((move.y > 0) ? (-player->pos.y >= to->y) : (-player->pos.y <= to->y))
	   ) {

   		currentNode = to;
   		player->pos.x = to->x;
   		player->pos.y = -to->y;

   		isJumping = false;
   		timer = 0.0;

   		SpammyReport("reached path end (%p)\n", to);

		if (to->type == dKPNode_s::CHANGE) {
			// Go to another map
			isMoving = false;

			SaveBlock *save = GetSaveFile()->GetBlock(-1);
			save->current_world = dScKoopatlas_c::instance->getIndexForMapName(to->destMap);

			SpammyReport("Change to map ID %d (%s), entrance ID %d\n", save->current_world, to->destMap, to->foreignID);

			DoSceneChange(WORLD_MAP, 0x10000000 | to->foreignID, 0);

		} else if (to->type != dKPNode_s::PASS_THROUGH) {
	   		// Stop here
	   		player->startAnimation(0, 1.2, 10.0, 0.0);
	   		player->hasEffect = false;
	   		player->hasSound = false;

	   		SpammyReport("stopping here\n");

	   		isMoving = false;

			SaveBlock *save = GetSaveFile()->GetBlock(-1);
			save->current_path_node = pathLayer->findNodeID(to);

			dWMHud_c::instance->showPointBar();
			SpammyReport("Point bar shown\n");
		} else {
			startMovementTo(to->getOppositeExitTo(currentPath));
			SpammyReport("passthrough node, continuing to next path\n");
		}
	}
}

void dWMPathManager_c::activatePoint() {
	if (currentNode->type == dKPNode_s::LEVEL) {
		int w = currentNode->levelNumber[0] - 1;
		int l = currentNode->levelNumber[1] - 1;

		if ((l > 29) && (l < 38)) {
			SaveBlock *save = GetSaveFile()->GetBlock(-1);
			u32 conds = save->GetLevelCondition(w, l);

			SpammyReport("Toad House Flags: %x", conds);
			if (conds & 0xFF0) { 

				MapSoundPlayer(SoundRelatedClass, SE_SYS_INVALID, 1);
				return; }
		}

		MapSoundPlayer(SoundRelatedClass, SE_SYS_GAME_START, 1);
		daWMPlayer_c::instance->startAnimation(170, 1.2, 10.0, 0.0);

		dLevelInfo_c::entry_s *level = dScKoopatlas_c::instance->levelInfo.search(w, l);
		dScKoopatlas_c::instance->startLevel(level);
	}
}