#define MAP_I 512
#define MAP_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I)
#define MAP_PLAYER_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 1)
#define MAP_ENEMY_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 2)
#define MAP_TREASURE_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 3)
#define MAP_BORDER_X_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 4)

#define FONT_BIG_I 256

void bigText(char* str, u16 x, u16 y, bool shadow){
	for(u8 i = 0; i < strlen(str); i++){
		if(str[i] >= 48){
			VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, (shadow ? 32 : 0) + FONT_BIG_I + str[i] - 48), x + i, y);
			VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, (shadow ? 32 : 0) + FONT_BIG_I + 16 + str[i] - 48), x + i, y + 1);
		}
	}
}

char scoreStr[SCORE_LENGTH];
u32 lastScore;
s16 scoreLength;

#define SCORE_X 1
#define SCORE_Y 5

#define LIFE_I (FONT_BIG_I + 64)
#define LIVES_X 38
#define LIVES_Y 5
s16 lastLives;

static void drawLives(){
	VDP_clearTileMapRect(BG_A, LIVES_X, LIVES_Y, 1, 16);
	for(u8 i = 0; i < (player.lives - 1); i++)
		VDP_fillTileMapRectInc(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, LIFE_I + (i > 0 ? 2 : 0)), LIVES_X, LIVES_Y + i, 1, 2);
	lastLives = player.lives;
}

// previous map positions: -1 means not drawn
s16 mapEnemyCol[ENEMY_COUNT], mapEnemyRow[ENEMY_COUNT];
s16 mapTreasureCol[TREASURE_COUNT], mapTreasureRow[TREASURE_COUNT];
s16 mapPlayerRow;

static void drawScore(){
	if(lastScore < 10) scoreLength = 1;
	else if(lastScore < 100) scoreLength = 2;
	else if(lastScore < 1000) scoreLength = 3;
	else if(lastScore < 10000) scoreLength = 4;
	else if(lastScore < 100000) scoreLength = 5;
	else if(lastScore < 1000000) scoreLength = 6;
	else if(lastScore < 10000000) scoreLength = 7;
	else scoreLength = 8;
	uintToStr(lastScore, scoreStr, scoreLength);
	bigText(scoreStr, SCORE_X, SCORE_Y, FALSE);
}

// load map when stage does so we have all enemies + player
void loadMap(){
	VDP_fillTileMapRect(BG_A, MAP_TILE, MAP_X, MAP_Y, MAP_W, MAP_H);

	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 4), MAP_X, MAP_Y - 1, MAP_W, 1);
	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 5), MAP_X, MAP_Y + MAP_H, MAP_W, 1);

	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 6), MAP_X - 1, MAP_Y, 1, MAP_H);
	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 6), MAP_X + MAP_W, MAP_Y, 1, MAP_H);

	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 7), MAP_X - 1, MAP_Y + MAP_H, 1, 1);
	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 7), MAP_X + MAP_W, MAP_Y + MAP_H, 1, 1);

	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 8), MAP_X - 1, MAP_Y - 1, 1, 1);
	VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 8), MAP_X + MAP_W, MAP_Y - 1, 1, 1);

	for(s16 i = 0; i < ENEMY_COUNT; i++){
		mapEnemyCol[i] = -1;
		mapEnemyRow[i] = -1;
	}
	for(s16 i = 0; i < TREASURE_COUNT; i++){
		mapTreasureCol[i] = -1;
		mapTreasureRow[i] = -1;
	}
	mapPlayerRow = -1;
}

// temp arrays for new positions
s16 mapNewCol[ENEMY_COUNT], mapNewRow[ENEMY_COUNT];
s16 mapNewTreasureCol[TREASURE_COUNT], mapNewTreasureRow[TREASURE_COUNT];

static bool mapTileOccupied(s16 col, s16 row, s16 pRow){
	// player always at center column
	if(col == MAP_W / 2 && row == pRow) return TRUE;
	for(s16 i = 0; i < ENEMY_COUNT; i++)
		if(mapNewCol[i] == col && mapNewRow[i] == row) return TRUE;
	for(s16 i = 0; i < TREASURE_COUNT; i++)
		if(mapNewTreasureCol[i] == col && mapNewTreasureRow[i] == row) return TRUE;
	return FALSE;
}

static void updateMap(){
	// compute new player row
	s16 pRow = fix32ToInt(player.pos.y) / 75;
	if(pRow < 0) pRow = 0;
	if(pRow >= MAP_H) pRow = MAP_H - 1;

	// compute new enemy positions
	for(s16 i = 0; i < ENEMY_COUNT; i++){
		if(!enemies[i].active || enemies[i].image == NULL
			|| enemies[i].pos.y < FIX32(0) || enemies[i].pos.y > GAME_H_F){
			mapNewCol[i] = -1;
			mapNewRow[i] = -1;
			continue;
		}
		fix32 dx = getWrappedDelta(enemies[i].pos.x, player.pos.x);
		s16 col = fix32ToInt(dx) / 54 + MAP_W / 2;
		if(col < 0) col = 0;
		if(col >= MAP_W) col = MAP_W - 1;
		s16 row = fix32ToInt(enemies[i].pos.y) / 75;
		if(row < 0) row = 0;
		if(row >= MAP_H) row = MAP_H - 1;
		mapNewCol[i] = col;
		mapNewRow[i] = row;
	}

	// compute new treasure positions
	for(s16 i = 0; i < TREASURE_COUNT; i++){
		if(!treasures[i].active || treasures[i].image == NULL || treasures[i].state == TREASURE_COLLECTED){
			mapNewTreasureCol[i] = -1;
			mapNewTreasureRow[i] = -1;
			continue;
		}
		fix32 dx = getWrappedDelta(treasures[i].pos.x, player.pos.x);
		s16 col = fix32ToInt(dx) / 54 + MAP_W / 2;
		if(col < 0) col = 0;
		if(col >= MAP_W) col = MAP_W - 1;
		s16 row = fix32ToInt(treasures[i].pos.y) / 75;
		if(row < 0) row = 0;
		if(row >= MAP_H) row = MAP_H - 1;
		mapNewTreasureCol[i] = col;
		mapNewTreasureRow[i] = row;
	}

	// clear old player tile if it moved and nothing new occupies it
	if(mapPlayerRow >= 0 && mapPlayerRow != pRow)
		if(!mapTileOccupied(MAP_W / 2, mapPlayerRow, pRow))
			VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + MAP_W / 2, MAP_Y + mapPlayerRow);

	// clear old enemy tiles that moved or disappeared
	for(s16 i = 0; i < ENEMY_COUNT; i++){
		if(mapEnemyCol[i] < 0) continue;
		if(mapEnemyCol[i] == mapNewCol[i] && mapEnemyRow[i] == mapNewRow[i]) continue;
		if(!mapTileOccupied(mapEnemyCol[i], mapEnemyRow[i], pRow))
			VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + mapEnemyCol[i], MAP_Y + mapEnemyRow[i]);
	}

	// clear old treasure tiles that moved or disappeared
	for(s16 i = 0; i < TREASURE_COUNT; i++){
		if(mapTreasureCol[i] < 0) continue;
		if(mapTreasureCol[i] == mapNewTreasureCol[i] && mapTreasureRow[i] == mapNewTreasureRow[i]) continue;
		if(!mapTileOccupied(mapTreasureCol[i], mapTreasureRow[i], pRow))
			VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + mapTreasureCol[i], MAP_Y + mapTreasureRow[i]);
	}

	// draw treasure dots (skip if player occupies same tile)
	for(s16 i = 0; i < TREASURE_COUNT; i++){
		mapTreasureCol[i] = mapNewTreasureCol[i];
		mapTreasureRow[i] = mapNewTreasureRow[i];
		if(mapNewTreasureCol[i] < 0) continue;
		if(mapNewTreasureCol[i] == MAP_W / 2 && mapNewTreasureRow[i] == pRow) continue;
		VDP_setTileMapXY(BG_A, MAP_TREASURE_TILE, MAP_X + mapNewTreasureCol[i], MAP_Y + mapNewTreasureRow[i]);
	}

	// draw enemy dots (skip if player occupies same tile)
	for(s16 i = 0; i < ENEMY_COUNT; i++){
		mapEnemyCol[i] = mapNewCol[i];
		mapEnemyRow[i] = mapNewRow[i];
		if(mapNewCol[i] < 0) continue;
		if(mapNewCol[i] == MAP_W / 2 && mapNewRow[i] == pRow) continue;
		VDP_setTileMapXY(BG_A, MAP_ENEMY_TILE, MAP_X + mapNewCol[i], MAP_Y + mapNewRow[i]);
	}

	// draw player dot on top
	mapPlayerRow = pRow;
	VDP_setTileMapXY(BG_A, MAP_PLAYER_TILE, MAP_X + MAP_W / 2, MAP_Y + pRow);
}

u8 phraseIndex[4];

s16 lastLevel;
static void drawLevel(){
	char lvlStr[4];
	uintToStr(level + 1, lvlStr, 1);
	VDP_drawText("LVL", 1, 8);
	VDP_drawText(lvlStr, 4, 8);
	lastLevel = level;
}

void loadChrome(){
	VDP_loadTileSet(imageFontBig.tileset, FONT_BIG_I, DMA);
	VDP_loadTileSet(imageFontBigShadow.tileset, FONT_BIG_I + 32, DMA);
	VDP_loadTileSet(imageChromeLife.tileset, LIFE_I, DMA);
	VDP_loadTileSet(imageChromeLife2.tileset, LIFE_I + 2, DMA);
	VDP_loadTileSet(mapIndicator.tileset, MAP_I, DMA);
	lastScore = 1;
	drawScore();
	drawLives();
	drawLevel();
}

bool didGameOver;
u32 gameOverClock;
static void doGameOver(){
	didGameOver = TRUE;
	for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL1);
	for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL1);
	for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active){
		if(treasures[i].state == TREASURE_COLLECTED){
			// spawn player bullet explosion at carried treasure position
			struct bulletSpawner spawner = {
				.x = treasures[i].pos.x, .y = treasures[i].pos.y,
				.anim = 0, .speed = 0, .angle = 0, .player = TRUE
			};
			void noop(s16 j){ (void)j; }
			spawnBullet(spawner, noop);
			for(s16 j = BULLET_COUNT - 1; j >= 0; j--){
				if(bullets[j].active && !bullets[j].explosion
					&& bullets[j].pos.x == treasures[i].pos.x && bullets[j].pos.y == treasures[i].pos.y){
					killBullet(j, TRUE);
					break;
				}
			}
		}
		killTreasure(i);
	}
	SPR_releaseSprite(player.image);

	// clear lives
	VDP_clearTileMapRect(BG_A, LIVES_X, LIVES_Y, 1, 16);

	// clear messages
	treasureCollectedClock = 0;
	allTreasureCollected = FALSE;
	hitMessageClock = 0;
	VDP_clearText(9, 5, 22);

	VDP_drawText("GAME  OVER", 15, 13);
	VDP_drawText("PRESS ANY BUTTON", 12, 14);
}

static void showPause(){
	for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL1);
	for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL1);
	for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active) SPR_setPalette(treasures[i].image, PAL1);
	SPR_setPalette(player.image, PAL1);
	XGM2_pause();
	VDP_drawText("PAUSE", 17, 13);
}

static void clearPause(){
	for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL0);
	for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL0);
	for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active) SPR_setPalette(treasures[i].image, PAL0);
	SPR_setPalette(player.image, PAL0);
	XGM2_resume();
	VDP_clearText(17, 13, 5);
}

u32 pauseClock;
static void updatePause(){
	if(gameOver) return;
	if(ctrl.start){
		if(!isPausing){
			isPausing = TRUE;
			if(!paused){
				pauseClock = 0;
				paused = TRUE;
				showPause();
			} else {
				paused = FALSE;
				clearPause();
			}
		}
	} else {
		isPausing = FALSE;
	}
	if(paused){
		if(pauseClock % 60 < 30)
			VDP_drawText("PAUSE", 17, 13);
		else
			VDP_clearText(17, 13, 5);
		pauseClock++;
		if(pauseClock >= 240) pauseClock = 0;
	}
}

void updateChrome(){
	updatePause();
	if(gameOver && !didGameOver) doGameOver();
	if(didGameOver){
		gameOverClock++;
		if((gameOverClock > 120 && (ctrl.a || ctrl.b || ctrl.c || ctrl.start)) || gameOverClock > 900)
			SYS_hardReset();
		return;
	}
	// level transition overlay
	if(levelClearing){
		if(levelClearClock == 2){
			char lvlStr[4];
			uintToStr(level + 2, lvlStr, 1);
			VDP_drawText("LEVEL ", 15, 13);
			VDP_drawText(lvlStr, 21, 13);
		}
		if(levelClearClock >= 110){
			VDP_clearText(15, 13, 10);
		}
		return;
	}
	if(lastScore != score){
		lastScore = score;
		drawScore();
	}
	if(lastLives != player.lives) drawLives();
	if(lastLevel != level) drawLevel();
	if(treasureCollectedClock > 0 && levelWaitClock == 0){
		if(treasureCollectedClock == 120){
			VDP_clearText(10, 5, 22);
			const char* mirrorPhrases[] = {"REFLECT THE DEPTHS", "DIG DEEPER WITHIN", "SEE WHAT SHINES BELOW", "MIRROR OF THE MINE", "LOOK BACK STRIKE BACK"};
			const char* lampPhrases[] = {"STRIKE LIGHT", "LET THERE BE LODE", "BRIGHT IDEA DEEP DOWN", "ILLUMINATE THE VEIN", "GLOW FROM BELOW"};
			const char* scarfPhrases[] = {"COZY IN THE CAVES", "WRAP THE UNDERWORLD", "SNUG AS BEDROCK", "STYLE FROM THE STRATA", "WARM THE DEPTHS"};
			const char* swordPhrases[] = {"ORE YOU READY", "MINED YOUR STEP", "CUTTING EDGE GEOLOGY", "STRIKE THE VEIN", "SPIRIT STEEL"};
			const char** sets[] = {mirrorPhrases, lampPhrases, scarfPhrases, swordPhrases};
			const char* phrase = sets[treasureCollectedType][phraseIndex[treasureCollectedType]];
			phraseIndex[treasureCollectedType] = (phraseIndex[treasureCollectedType] + 1) % 5;
			u8 len = strlen(phrase);
			VDP_drawText(phrase, 20 - len / 2, 5);
		}
		treasureCollectedClock--;
		if(treasureCollectedClock == 0){
			VDP_clearText(10, 5, 22);
			// check if all treasures are collected or gone
			bool allDone = TRUE;
			for(s16 j = 0; j < TREASURE_COUNT; j++){
				if(treasures[j].active && treasures[j].state != TREASURE_COLLECTED){
					allDone = FALSE;
					break;
				}
			}
			if(allDone && collectedCount > 0){
				allTreasureCollected = TRUE;
				VDP_drawText("ALL TREASURE COLLECTED", 9, 5);
			}
		}
	}
	if(hitMessageClock > 0){
		if(hitMessageClock == 120){
			VDP_clearText(9, 5, 22);
			treasureCollectedClock = 0;
			allTreasureCollected = FALSE;
			VDP_drawText(hitMessageBullet ? "BLASTED" : "SMASHED", hitMessageBullet ? 16 : 16, 5);
		}
		hitMessageClock--;
		if(hitMessageClock == 0)
			VDP_clearText(9, 5, 22);
	}
	if(levelWaitClock == 240){
		VDP_clearText(9, 5, 22);
		treasureCollectedClock = 0;
		allTreasureCollected = FALSE;
		VDP_drawText("ALL ENEMIES DESTROYED", 9, 5);
	}
	if(clock % 4 == 0) updateMap();
}