#include "koopatlas/core.h"
#include "koopatlas/camera.h"
#include "koopatlas/player.h"
#include "koopatlas/hud.h"

extern "C" void LoadMapScene();

dScKoopatlas_c *dScKoopatlas_c::instance = 0;

CREATE_STATE_E(dScKoopatlas_c, Limbo);
CREATE_STATE_E(dScKoopatlas_c, ContinueWait);
CREATE_STATE_E(dScKoopatlas_c, Normal);
CREATE_STATE_E(dScKoopatlas_c, CSMenu);
CREATE_STATE_E(dScKoopatlas_c, TitleConfirmOpenWait);
CREATE_STATE_E(dScKoopatlas_c, TitleConfirmSelect);
CREATE_STATE_E(dScKoopatlas_c, TitleConfirmHitWait);
CREATE_STATE_E(dScKoopatlas_c, PlayerChangeWait);
CREATE_STATE_E(dScKoopatlas_c, EasyPairingWait);
CREATE_STATE_E(dScKoopatlas_c, PowerupsWait);
CREATE_STATE_E(dScKoopatlas_c, SaveOpen);
CREATE_STATE_E(dScKoopatlas_c, SaveSelect);
CREATE_STATE_E(dScKoopatlas_c, SaveWindowClose);
CREATE_STATE_E(dScKoopatlas_c, SaveDo);
CREATE_STATE_E(dScKoopatlas_c, SaveEndWindow);
CREATE_STATE_E(dScKoopatlas_c, SaveEndCloseWait);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveOpen);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveSelect);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveWindowClose);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveDo);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveEndWindow);
CREATE_STATE_E(dScKoopatlas_c, QuickSaveEndCloseWait);
CREATE_STATE_E(dScKoopatlas_c, SaveError);

dScKoopatlas_c *dScKoopatlas_c::build() {
	// return new dScKoopatlas_c;
	MapReport("Creating WorldMap\n");

	void *buffer = AllocFromGameHeap1(sizeof(dScKoopatlas_c));
	dScKoopatlas_c *c = new(buffer) dScKoopatlas_c;

	MapReport("Created WorldMap @ %p\n", c);

	instance = c;
	return c;
}

bool WMInit_StartLoading(void*);
bool WMInit_LoadSIAnims(void*);
bool WMInit_EndLoading(void*);
bool WMInit_LoadResources(void*);
bool WMInit_SetupWait(void*);
bool WMInit_SetupExtra(void*);
bool WMInit_SetupWipe(void*);

ChainedFunc initFunctions[] = {
	WMInit_StartLoading,
	WMInit_LoadSIAnims,
	WMInit_EndLoading,
	WMInit_LoadResources,
	WMInit_SetupWait,
	WMInit_SetupExtra,
	WMInit_SetupWipe
};

dScKoopatlas_c::dScKoopatlas_c() : state(this) {
	initChain.setup(initFunctions, 7);

	setInitChain(initChain);
}



#define SELC_SETUP_DONE(sc) (*((bool*)(((u32)(sc))+0xD38)))

#define EASYP_SETUP_DONE(ep) (*((bool*)(((u32)(ep))+0x278)))
#define EASYP_ACTIVE(ep) (*((bool*)(((u32)(ep))+0x279)))

#define CSMENU_SETUP_DONE(csm) (*((bool*)(((u32)(csm))+0x270)))
#define CSMENU_ACTIVE(csm) (*((bool*)(((u32)(csm))+0x271)))
#define CSMENU_CHOICE_OK(csm) (*((bool*)(((u32)(csm))+0x272)))
#define CSMENU_UNK(csm) (*((bool*)(((u32)(csm))+0x273)))
#define CSMENU_CURRENT(csm) (*((int*)(((u32)(csm))+0x268)))

#define YESNO_SETUP_DONE(ynw) (*((bool*)(((u32)(ynw))+0x294)))
#define YESNO_VISIBLE(ynw) (*((bool*)(((u32)(ynw))+0x295)))
#define YESNO_CLOSE(ynw) (*((bool*)(((u32)(ynw))+0x296)))
#define YESNO_OPENING(ynw) (*((bool*)(((u32)(ynw))+0x297)))
#define YESNO_REFUSED(ynw) (*((bool*)(((u32)(ynw))+0x298)))
#define YESNO_CANCELLED(ynw) (*((bool*)(((u32)(ynw))+0x299)))
#define YESNO_CANCELLED2(ynw) (*((bool*)(((u32)(ynw))+0x29A)))
#define YESNO_CURRENT(ynw) (*((int*)(((u32)(ynw))+0x284)))
#define YESNO_TYPE(ynw) (*((int*)(((u32)(ynw))+0x28C)))

#define NPCHG_SETUP_DONE(npc) (*((bool*)(((u32)(npc))+0x67C)))
#define NPCHG_ACTIVE(npc) (*((bool*)(((u32)(npc))+0x67E)))
#define NPCHG_HIDE_FOR_EASYP(npc) (*((bool*)(((u32)(npc))+0x67F)))
#define NPCHG_READY(npc) (*((bool*)(((u32)(npc))+0x680)))
#define NPCHG_CCSB(npc,idx) (((void**)(((u32)(npc))+0x74))[(idx)])
#define NPCHG_CCSC(npc,idx) (((void**)(((u32)(npc))+0x84))[(idx)])
#define NPCHG_CCSA(npc,idx) (((void**)(((u32)(npc))+0x94))[(idx)])
#define NPCHG_CCI(npc,idx) (((void**)(((u32)(npc))+0xA4))[(idx)])
#define NPCHG_2DPLAYER(npc,idx) (((void**)(((u32)(npc))+0x64C))[(idx)])

#define STKI_SETUP_DONE(si) (*((bool*)(((u32)(si))+0x310)))
#define STKI_SHADOW(si) (*((void**)(((u32)(si))+0x310)))
#define STKI_2DPLAYER(si,idx) (((void**)(((u32)(si))+0x2E4))[(idx)])
#define STKI_ITEM(si,idx) (((void**)(((u32)(si))+0x2F4))[(idx)])
#define STKI_SHOW(si) (*((bool*)(((u32)(si))+0x8DD)))

#define SIS_SETUP_DONE(sis) (*((bool*)(((u32)(sis))+0x260)))

#define CCSB_ACTIVE(ccsb) (*((bool*)(((u32)(ccsb))+0x29C)))

#define CCSC_ACTIVE(ccsc) (*((bool*)(((u32)(ccsc))+0x2A1)))

#define PLAYER2D_SHOW_EASY_PAIRING(p2d) (*((bool*)(((u32)(p2d))+0x264)))

#define CONT_LIVES(cont,idx) (((int*)(((u32)(cont))+0x2B8))[(idx)])
#define CONT_SETUP_DONE(cont) (*((bool*)(((u32)(cont))+0x2D4)))
#define CONT_UNK1(cont) (*((bool*)(((u32)(cont))+0x2D5)))
#define CONT_UNK2(cont) (*((bool*)(((u32)(cont))+0x2D6)))
#define CONT_DONE(cont) (*((bool*)(((u32)(cont))+0x2D7)))
#define CONT_UNK3(cont) (*((bool*)(((u32)(cont))+0x2E0)))

bool WMInit_StartLoading(void *ptr) {
	SpammyReport("WMInit_StartLoading called\n");

	DVD_Start();
	return true;
}

bool WMInit_LoadSIAnims(void *ptr) {
	SpammyReport("WMInit_LoadSIAnims called\n");

	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_kinoko", 0);
	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_fireflower", 0);
	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_iceflower", 0);
	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_penguin", 0);
	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_propeller", 0);
	DVD_LoadFile(GetDVDClass(), "WorldMap", "SI_star", 0);
	return true;
}

bool WMInit_EndLoading(void *ptr) {
	SpammyReport("WMInit_EndLoading called\n");

	if (DVD_StillLoading(GetDVDClass2())) {
		SpammyReport("WMInit_EndLoading returning false\n");
		return false;
	}

	DVD_End();
	SpammyReport("WMInit_EndLoading returning true\n");
	return true;
}

bool WMInit_LoadResources(void *ptr) {
	SpammyReport("WMInit_LoadResources returning true\n");

	dScKoopatlas_c *wm = (dScKoopatlas_c*)ptr;
	return wm->mapData.load("/Maps/yat.kpbin");
	//TODO
	//return wm->resMng.loadSet("MMFullWorld");
	//return true;
}

bool WMInit_SetupWait(void *ptr) {
	SpammyReport("WMInit_SetupWait called\n");

	dScKoopatlas_c *wm = (dScKoopatlas_c*)ptr;

	bool success = true;

	success &= CSMENU_SETUP_DONE(wm->csMenu);
	success &= SELC_SETUP_DONE(wm->selectCursor);
	success &= NPCHG_SETUP_DONE(wm->numPeopleChange);
	success &= YESNO_SETUP_DONE(wm->yesNoWindow);
	success &= CONT_SETUP_DONE(wm->continueObj);
	success &= STKI_SETUP_DONE(wm->stockItem);
	success &= SIS_SETUP_DONE(wm->stockItemShadow);
	success &= EASYP_SETUP_DONE(wm->easyPairing);

	return success;
}

bool WMInit_SetupExtra(void *ptr) {
	SpammyReport("WMInit_SetupExtra called\n");

	// ok, now we can set up other required shit
	dScKoopatlas_c *wm = (dScKoopatlas_c*)ptr;

	// first up: player models for Stocked Items
	for (int i = 0; i < 4; i++) {
		void *obj = CreateChildObject(WM_2D_PLAYER, wm, i, 0, 0);
		STKI_2DPLAYER(wm->stockItem,i) = obj;
		NPCHG_2DPLAYER(wm->numPeopleChange,i) = obj;
	}

	// next: items for the Powerup screen
	for (int i = 0; i < 7; i++) {
		void *obj = CreateChildObject(WM_ITEM, wm, i, 0, 0);
		STKI_ITEM(wm->stockItem,i) = obj;
	}

	// since we've got all the resources, set up the path data too
	//wm->pathManager->setup();
	//wm->pathManager->computeEvents();

	// and now Player setup
	wm->player = (daWMPlayer_c*)CreateParentedObject(WM_PLAYER, wm, 0, 2);
	wm->player->modelHandler->mdlClass->setPowerup(2);
	wm->player->modelHandler->mdlClass->startAnimation(0, 1.2f, 10.0f, 0.0f);
	//wm->player->pos = wm->pathManager->currentPoint->position;

	// is last param correct? must check :/
	wm->map = (dWMMap_c*)CreateParentedObject(WM_MAP, wm, 0, 0);
	wm->hud = (dWMHud_c*)CreateParentedObject(WM_HUD, wm, 0, 0);
	// note: world_camera and wm_path_manager are not created here
	// because we require them earlier
	// they are created in dScKoopatlas_c::onCreate

	return true;
}

bool WMInit_SetupWipe(void *ptr) {
	SpammyReport("WMInit_SetupWipe called\n");

	dScKoopatlas_c *wm = (dScKoopatlas_c*)ptr;

	if (wm->hasUninitialisedProcesses()) {
		SpammyReport("WMInit_SetupWipe returning false\n");
		return false;
	}

	SpammyReport("WMInit_SetupWipe returning true\n");
	return true;
}





/*void dScKoopatlas_c::startLevel(LevelInfo::Entry *entry) {
  for (int i = 0; i < 4; i++) {
  bool isThere = QueryPlayerAvailability(i);
  int id = Player_ID[i];
  Player_Active[i] = isThere ? 1 : 0;
  if (!isThere) Player_Flags[i] = 0;
  }

  StartLevelInfo sl;
  sl.unk1 = 0;
  sl.unk2 = 0xFF;
  sl.unk3 = 0;
  sl.unk4 = 0;
  sl.purpose = 0;

  sl.world1 = entry->world;
  sl.world2 = entry->world;
  sl.level1 = entry->level;
  sl.level2 = entry->level;

// hopefully this will fix the Star Coin issues
SetSomeConditionShit(entry->world, entry->level, 2);

ActivateWipe(WIPE_MARIO);

DoStartLevel(GetGameMgr(), &sl);
}*/


int dScKoopatlas_c::onCreate() {
	SpammyReport("onCreate() called\n");

	SpammyReport("LoadMapScene()\n");
	LoadMapScene();

	SpammyReport("GameSetup__LoadScene(0)\n");
	GameSetup__LoadScene(0); // lol, stolen from GAME_SETUP


	SpammyReport("select cursor\n");
	this->selectCursor = CreateParentedObject(SELECT_CURSOR, this, 0, 0);

	SpammyReport("cs menu\n");
	this->csMenu = CreateParentedObject(COURSE_SELECT_MENU, this, 0, 0);

	SpammyReport("yes no window\n");
	this->yesNoWindow = CreateParentedObject(YES_NO_WINDOW, this, 0, 0);

	SpammyReport("number of people change\n");
	this->numPeopleChange = CreateParentedObject(NUMBER_OF_PEOPLE_CHANGE, this, 0, 0);

	for (int i = 0; i < 4; i++) {
		SpammyReport("ccsb %d\n", i);
		void *ccsb = CreateParentedObject(CHARACTER_CHANGE_SELECT_BASE, this, i, 0);
		SpammyReport("ccsc %d\n", i);
		void *ccsc = CreateParentedObject(CHARACTER_CHANGE_SELECT_CONTENTS, this, i, 0);
		SpammyReport("ccsa %d\n", i);
		void *ccsa = CreateParentedObject(CHARACTER_CHANGE_SELECT_ARROW, this, i, 0);
		SpammyReport("ccsi %d\n", i);
		void *cci = CreateParentedObject(CHARACTER_CHANGE_INDICATOR, this, i, 0);

		NPCHG_CCSB(this->numPeopleChange, i) = ccsb;
		NPCHG_CCSC(this->numPeopleChange, i) = ccsc;
		NPCHG_CCSA(this->numPeopleChange, i) = ccsa;
		NPCHG_CCI(this->numPeopleChange, i) = cci;
	}

	SpammyReport("continue\n");
	this->continueObj = CreateParentedObject(CONTINUE, this, 0, 0);

	// check if we need to handle Continue
	if (CheckIfContinueShouldBeActivated()) {
		SpammyReport("continue is activated\n");
		state.setState(&StateID_ContinueWait);
		CONT_UNK1(this->continueObj) = true;
		CONT_UNK2(this->continueObj) = true;
		CONT_UNK3(this->continueObj) = false;
	} else {
		SpammyReport("continue is not activated\n");
		state.setState(&StateID_Normal);
	}

	SpammyReport("stock item\n");
	this->stockItem = CreateParentedObject(STOCK_ITEM, this, 0, 0);
	SpammyReport("stock item shadow\n");
	this->stockItemShadow = CreateParentedObject(STOCK_ITEM_SHADOW, this, 0, 0);
	STKI_SHADOW(this->stockItem) = this->stockItemShadow;

	SpammyReport("easy pairing\n");
	this->easyPairing = CreateParentedObject(EASY_PAIRING, this, 0, 0);

	SpammyReport("world camera\n");
	CreateParentedObject(WORLD_CAMERA, this, 0, 0);

	/*pathManager = (dWMPathManager_c*)CreateParentedObject(WM_PATH_MANAGER, this, 0, 0);*/

	SpammyReport("setting NewerMapDrawFunc\n");
	*CurrentDrawFunc = NewerMapDrawFunc;

	// level info
	/*SpammyReport("loading level info file\n");
	levelInfoFile.open("/NewerRes/LevelInfo.bin");
	SpammyReport("preparing level info\n");
	levelInfo.load(levelInfoFile.ptr());*/

	SpammyReport("onCreate() completed\n");
	return true;
}

int dScKoopatlas_c::onDelete() {
	FreeScene(0);
	FreeScene(1);

	DVD_FreeFile(GetDVDClass2(), "SI_kinoko");
	DVD_FreeFile(GetDVDClass2(), "SI_fireflower");
	DVD_FreeFile(GetDVDClass2(), "SI_iceflower");
	DVD_FreeFile(GetDVDClass2(), "SI_penguin");
	DVD_FreeFile(GetDVDClass2(), "SI_propeller");
	DVD_FreeFile(GetDVDClass2(), "SI_star");

	return true;
}

bool dScKoopatlas_c::canDoStuff() {
	if (QueryGlobal5758(0xFFFFFFFF)) return false;
	if (CheckIfWeCantDoStuff()) return false;
	if (state.getCurrentState() == &StateID_Limbo) return false;
	return true;
}


int dScKoopatlas_c::onExecute() {
	if (!canDoStuff()) return true;

	SpammyReport("Executing state: %s\n", state.getCurrentState()->getName());
	state.execute();

	return true;
}


void dScKoopatlas_c::executeState_Limbo() { }


void dScKoopatlas_c::executeState_ContinueWait() {
	// Waiting for the Continue anim to finish
	if (CONT_DONE(this->continueObj)) {
		CONT_UNK1(this->continueObj) = 0;
		CONT_UNK2(this->continueObj) = 0;
		CONT_UNK3(this->continueObj) = 0;

		for (int i = 0; i < 4; i++) {
			int idx = SearchForIndexOfPlayerID(i);
			Player_Lives[Player_ID[idx]] = CONT_LIVES(this->continueObj, i);
		}

		state.setState(&StateID_Normal);
	}
}

void dScKoopatlas_c::executeState_Normal() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	// Nothing related to the menu is going on
	if (nowPressed & WPAD_ONE) {
		STKI_SHOW(this->stockItem) = true;
		state.setState(&StateID_PowerupsWait);
	} else if (nowPressed & WPAD_PLUS) {
		CSMENU_ACTIVE(this->csMenu) = true;
		state.setState(&StateID_CSMenu);
	}
}

void dScKoopatlas_c::executeState_CSMenu() {
	// The course select menu is currently being shown

	// First off, check to see if it's been hidden
	if (!CSMENU_ACTIVE(this->csMenu)) {
		// That means something happened
		if (CSMENU_CHOICE_OK(this->csMenu)) {
			// Player pressed a button

			switch (CSMENU_CURRENT(this->csMenu)) {
				case 0:
					// Star Coins
					MapReport("Star Coins was pressed\n");
					state.setState(&StateID_Normal);
					break;

				case 1:
					// Add/Drop Players
					MapReport("Add/Drop Players was pressed\n");
					state.setState(&StateID_PlayerChangeWait);
					NPCHG_ACTIVE(this->numPeopleChange) = true;
					WpadShit(10);

					break;

				case 2:
					// Save or Quick Save
					MapReport("Save or Quick Save was pressed\n");
					if (GetSaveFile()->GetBlock(-1)->bitfield & 2) {
						state.setState(&StateID_SaveOpen);
						YESNO_TYPE(this->yesNoWindow) = 1;
						YESNO_VISIBLE(this->yesNoWindow) = 1;

					} else {
						state.setState(&StateID_QuickSaveOpen);
						YESNO_TYPE(this->yesNoWindow) = 15;
						YESNO_VISIBLE(this->yesNoWindow) = 1;

					}

					break;

				case 3:
					// Title Screen
					MapReport("Title Screen was pressed\n");
					state.setState(&StateID_TitleConfirmOpenWait);
					YESNO_VISIBLE(this->yesNoWindow) = true;
					YESNO_TYPE(this->yesNoWindow) = 10;
					break;
			}

		} else {
			// Ok, change back to STATE_Normal
			state.setState(&StateID_Normal);
		}
	}
}

void dScKoopatlas_c::executeState_TitleConfirmOpenWait() {
	// Waiting for the "Go to Title Screen" YesNoWindow to finish opening

	if (!YESNO_OPENING(this->yesNoWindow)) {
		state.setState(&StateID_TitleConfirmSelect);
	}

}

/**********************************************************************/
// STATE_TitleConfirmSelect : Let the user choose an option on the
// 	"Go to Title Screen" YesNoWindow.
void dScKoopatlas_c::executeState_TitleConfirmSelect() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	if (nowPressed & WPAD_LEFT) {
		// Select "OK!"
		YESNO_CURRENT(this->yesNoWindow) = 1;

	} else if (nowPressed & WPAD_RIGHT) {
		// Select "Cancel"
		YESNO_CURRENT(this->yesNoWindow) = 0;

	} else if (Wiimote_TestButtons(GetActiveWiimote(), WPAD_A | WPAD_TWO)) {
		// Pick the current option
		YESNO_CLOSE(this->yesNoWindow) = true;
		if (YESNO_CURRENT(this->yesNoWindow) != 1)
			YESNO_REFUSED(this->yesNoWindow) = true;
		state.setState(&StateID_TitleConfirmHitWait);

	} else {
		// Cancel using B or 1
		if (CheckIfMenuShouldBeCancelledForSpecifiedWiimote(0)) {
			YESNO_CANCELLED(this->yesNoWindow) = true;
			YESNO_CURRENT(this->yesNoWindow) = true;
			state.setState(&StateID_TitleConfirmHitWait);
		}
	}

}

/**********************************************************************/
// STATE_TitleConfirmHitWait : Process the user's chosen option on
// 	the "Go to Title Screen" YesNoWindow. Also, wait for the
//  animation to be complete.
void dScKoopatlas_c::executeState_TitleConfirmHitWait() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		if (YESNO_CURRENT(this->yesNoWindow) == 1) {
			state.setState(&StateID_Normal);
		} else {
			state.setState(&StateID_Limbo);
			StartTitleScreenStage(false, 0);
		}
	}

}

/**********************************************************************/
// STATE_PlayerChangeWait : Wait for the user to do something on the
// 	Add/Drop Players screen.
void dScKoopatlas_c::executeState_PlayerChangeWait() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	if (NPCHG_READY(this->numPeopleChange)) {
		if (nowPressed & WPAD_PLUS) {
			// activate easy pairing. FUN !!
			NPCHG_HIDE_FOR_EASYP(this->numPeopleChange) = 1;

			for (int i = 0; i < 4; i++) {
				void *obj = NPCHG_2DPLAYER(this->numPeopleChange, i);
				void *ccsb = NPCHG_CCSB(this->numPeopleChange, i);
				void *ccsc = NPCHG_CCSC(this->numPeopleChange, i);

				PLAYER2D_SHOW_EASY_PAIRING(obj) = 1;
				CCSB_ACTIVE(ccsb) = 1;
				CCSC_ACTIVE(ccsc) = 1;
			}

			EASYP_ACTIVE(this->easyPairing) = 1;
			state.setState(&StateID_EasyPairingWait);
		}
	} else {
		if (!NPCHG_ACTIVE(this->numPeopleChange)) {
			state.setState(&StateID_Normal);
		}
	}

}

/**********************************************************************/
// STATE_EasyPairingWait : Wait for the user to exit Easy Pairing.
void dScKoopatlas_c::executeState_EasyPairingWait() {

	if (!EASYP_ACTIVE(this->easyPairing)) {
		NPCHG_HIDE_FOR_EASYP(this->numPeopleChange) = 0;

		for (int i = 0; i < 4; i++) {
			void *obj = NPCHG_2DPLAYER(this->numPeopleChange, i);
			void *ccsb = NPCHG_CCSB(this->numPeopleChange, i);
			void *ccsc = NPCHG_CCSC(this->numPeopleChange, i);

			PLAYER2D_SHOW_EASY_PAIRING(obj) = 0;
			CCSB_ACTIVE(ccsb) = 0;
			CCSC_ACTIVE(ccsc) = 0;
		}

		state.setState(&StateID_PlayerChangeWait);
		WpadShit(10);
	}

}

/**********************************************************************/
// STATE_PowerupsWait : Wait for the user to exit the Powerups screen.
void dScKoopatlas_c::executeState_PowerupsWait() {

	if (!STKI_SHOW(this->stockItem)) {
		state.setState(&StateID_Normal);
	}

}

/**********************************************************************/
// STATE_SaveOpen : Waiting for the "Save?" YesNoWindow to open
void dScKoopatlas_c::executeState_SaveOpen() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		state.setState(&StateID_SaveSelect);
	}

}

/**********************************************************************/
// STATE_SaveSelect : Let the user choose an option on the
// 	"Save?" YesNoWindow.
void dScKoopatlas_c::executeState_SaveSelect() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	if (nowPressed & WPAD_LEFT) {
		// Select "OK!"
		YESNO_CURRENT(this->yesNoWindow) = 1;

	} else if (nowPressed & WPAD_RIGHT) {
		// Select "Cancel"
		YESNO_CURRENT(this->yesNoWindow) = 0;

	} else if (Wiimote_TestButtons(GetActiveWiimote(), WPAD_A | WPAD_TWO)) {
		// Pick the current option
		YESNO_CLOSE(this->yesNoWindow) = true;

		if (YESNO_CURRENT(this->yesNoWindow) != 1)
			YESNO_CANCELLED2(this->yesNoWindow) = true;
		state.setState(&StateID_SaveWindowClose);

	} else {
		// Cancel using B or 1
		if (CheckIfMenuShouldBeCancelledForSpecifiedWiimote(0)) {
			YESNO_CANCELLED(this->yesNoWindow) = true;
			YESNO_CURRENT(this->yesNoWindow) = 1;
			state.setState(&StateID_SaveWindowClose);
		}
	}

}

/**********************************************************************/
// STATE_SaveWindowClose : Process the user's chosen option on the
// 	"Save?" YesNoWindow. Also, wait for the animation to be complete.
void dScKoopatlas_c::executeState_SaveWindowClose() {

	if (!YESNO_VISIBLE(this->yesNoWindow)) {
		if (YESNO_CURRENT(this->yesNoWindow) == 1) {
			state.setState(&StateID_Normal);
		} else {
			state.setState(&StateID_SaveDo);
			SaveGame(0, false);
		}
	}

}

/**********************************************************************/
// STATE_SaveDo : Save the game.
void dScKoopatlas_c::executeState_SaveDo() {

	if (!GetSaveFile()->CheckIfWriting()) {
		if (GetSaveHandler()->CurrentError == 0) {
			YESNO_TYPE(this->yesNoWindow) = 2;
			YESNO_VISIBLE(this->yesNoWindow) = true;
			state.setState(&StateID_SaveEndWindow);
		} else {
			state.setState(&StateID_SaveError);
		}
	}

}

/**********************************************************************/
// STATE_SaveEndWindow : Handle the Save End window.
void dScKoopatlas_c::executeState_SaveEndWindow() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		if (Wiimote_TestButtons(GetActiveWiimote(), WPAD_A | WPAD_TWO)) {
			YESNO_CLOSE(this->yesNoWindow) = true;
			state.setState(&StateID_SaveEndCloseWait);
		}
	}

}

/**********************************************************************/
// STATE_SaveEndCloseWait : Wait for the Save End window to close.
void dScKoopatlas_c::executeState_SaveEndCloseWait() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		state.setState(&StateID_Normal);
	}

}

/**********************************************************************/
// STATE_QuickSaveOpen : Waiting for the "Save?" YesNoWindow to open
void dScKoopatlas_c::executeState_QuickSaveOpen() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		state.setState(&StateID_QuickSaveSelect);
	}

}

/**********************************************************************/
// STATE_QuickSaveSelect : Let the user choose an option on the
// 	"Save?" YesNoWindow.
void dScKoopatlas_c::executeState_QuickSaveSelect() {
	int nowPressed = Remocon_GetPressed(GetActiveRemocon());

	if (nowPressed & WPAD_LEFT) {
		// Select "OK!"
		YESNO_CURRENT(this->yesNoWindow) = 1;

	} else if (nowPressed & WPAD_RIGHT) {
		// Select "Cancel"
		YESNO_CURRENT(this->yesNoWindow) = 0;

	} else if (Wiimote_TestButtons(GetActiveWiimote(), WPAD_A | WPAD_TWO)) {
		// Pick the current option
		YESNO_CLOSE(this->yesNoWindow) = true;

		if (YESNO_CURRENT(this->yesNoWindow) != 1)
			YESNO_CANCELLED2(this->yesNoWindow) = true;
		state.setState(&StateID_QuickSaveWindowClose);

	} else {
		// Cancel using B or 1
		if (CheckIfMenuShouldBeCancelledForSpecifiedWiimote(0)) {
			YESNO_CANCELLED(this->yesNoWindow) = true;
			YESNO_CURRENT(this->yesNoWindow) = 1;
			state.setState(&StateID_QuickSaveWindowClose);
		}
	}

}

/**********************************************************************/
// STATE_QuickSaveWindowClose : Process the user's chosen option on
// 	the "Save?" YesNoWindow. Also, wait for the animation to be complete
void dScKoopatlas_c::executeState_QuickSaveWindowClose() {

	if (!YESNO_VISIBLE(this->yesNoWindow)) {
		if (YESNO_CURRENT(this->yesNoWindow) == 1) {
			state.setState(&StateID_Normal);
		} else {
			state.setState(&StateID_QuickSaveDo);
			SaveGame(0, true);
		}
	}

}

/**********************************************************************/
// STATE_QuickSaveDo : Save the game.
void dScKoopatlas_c::executeState_QuickSaveDo() {

	if (!GetSaveFile()->CheckIfWriting()) {
		if (GetSaveHandler()->CurrentError == 0) {
			YESNO_TYPE(this->yesNoWindow) = 16;
			YESNO_VISIBLE(this->yesNoWindow) = true;
			state.setState(&StateID_QuickSaveEndWindow);
		} else {
			state.setState(&StateID_SaveError);
		}
	}

}

// STATE_QuickSaveEndWindow : Handle the Save End window.
void dScKoopatlas_c::executeState_QuickSaveEndWindow() {

	if (!YESNO_OPENING(this->yesNoWindow)) {
		if (Wiimote_TestButtons(GetActiveWiimote(), WPAD_A | WPAD_TWO)) {
			YESNO_CLOSE(this->yesNoWindow) = true;
			YESNO_REFUSED(this->yesNoWindow) = true;
			state.setState(&StateID_QuickSaveEndCloseWait);
		}
	}

}

void dScKoopatlas_c::executeState_QuickSaveEndCloseWait() {
	// Wait for Save End window to close

	if (!YESNO_OPENING(this->yesNoWindow)) {
		if (YESNO_CURRENT(this->yesNoWindow) == 1) {
			state.setState(&StateID_Normal);
		} else {
			state.setState(&StateID_Limbo);
			StartTitleScreenStage(false, 0);
		}
	}

}


void dScKoopatlas_c::executeState_SaveError() { }


/*
// MODELLED ON STAGE
void NewerMapDrawFunc() {
	DoSomethingCameraRelatedWithEGGScreen(0, &dWorldCamera_c::instance->screen);
	LinkScene(0);
	ChangeAlphaUpdate(false);
	SceneCalcWorld(0);
	SceneCameraStuff(0);
	DrawOpa();
	DrawXlu();
	// Something
	nw4r::g3d::Camera camera(GetCameraByID(0));
	camera.GXSetViewport();
	camera.GXSetScissor();
	RenderEffects(0, 6);
	SetupLYTDrawing();
	DrawAllLayoutsBeforeX(0x81);
	RenderEffects(0, 3);
	RenderEffects(0, 2);
	DrawAllLayoutsAfterX(0x80);
	ClearLayoutDrawList();
	UnlinkScene(0);
}*/


void NewerMapDrawFunc() {
	Reset3DState();
	SetCurrentCameraID(0);
	DoSomethingCameraRelatedWithEGGScreen(0, &dWorldCamera_c::instance->screen);
	LinkScene(0);
	SceneCalcWorld(0);
	SceneCameraStuff(0);
	ChangeAlphaUpdate(false);
	DrawOpa();
	DrawXlu();
	UnlinkScene(0);
	// Something
	SetupLYTDrawing();
	DrawAllLayoutsBeforeX(0x81);
	RenderEffects(0, 3);
	RenderEffects(0, 2);
	GXDrawDone();
	RemoveAllFromScnRoot();
	Reset3DState();
	SetCurrentCameraID(1);
	DoSpecialDrawing1();
	LinkScene(1);
	SceneCalcWorld(1);
	SceneCameraStuff(1);
	CalcMaterial();
	DrawOpa();
	DrawXlu();
	UnlinkScene(1);
	GXDrawDone();
	// Leaving out some stuff here
	DrawAllLayoutsAfterX(0x80);
	ClearLayoutDrawList();
	SetCurrentCameraID(0);
}


/*void NewerMapDrawFunc() {
	int keepCamera = GetCurrentCameraID();

	// All drawing uses scene 1, since that's the only one loaded by GAME_SETUP.
	// Todo: Newer-specific scenes?

	// Stage 1

	// Stage 2
	Reset3DState();
	SetCurrentCameraID(0);
	LinkScene(0);
	SceneCalcWorld(0);
	SceneCameraStuff(0);
	ChangeAlphaUpdate(false);
	CalcMaterial();
	DrawOpa();
	DrawXlu();
	UnlinkScene(0);
	GXDrawDone();

	//Reset3DState();
	//T3D::DrawQueue();

	// Stage 3
	Reset3DState();
	SetupLYTDrawing();
	DrawAllLayoutsBeforeX(146);
	//DrawAllLayoutsBeforeX(129);
	//DrawAllLayoutsAfterXandBeforeY(128, 146);
	GXDrawDone();

	// Stage 4
	RemoveAllFromScnRoot();
	Reset3DState();
	SetCurrentCameraID(1);
	DoSpecialDrawing1();
	LinkScene(1);
	SceneCalcWorld(1);
	SceneCameraStuff(1);
	CalcMaterial();
	DrawOpa();
	DrawXlu();

	// Stage 5
	if (GAMEMGR_GET_AFC(GameMgr)) {
		for (int i = 0; i < 4; i++) {
			RenderEffects(0, 11+i);
		}

		for (int i = 0; i < 4; i++) {
			RenderEffects(0, 7+i);
		}
	}

	RenderEffects(0, 2); // need to investigate how this thing works

	DrawAllLayoutsAfterX(145);
	ClearLayoutDrawList(); // this is REALLY IMPORTANT!

	UnlinkScene(1);

	// End
	SetCurrentCameraID(0);
}

*/