/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
// PokerChip class: draggable, rotatable, circular
var PokerChip = Container.expand(function () {
	var self = Container.call(this);
	// Asset id and color are passed in
	self.assetId = self.assetId || 'chipRed';
	var chip = self.attachAsset(self.assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// For rotation handle
	var handle = self.attachAsset('chipWhite', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.18,
		scaleY: 0.18,
		y: -chip.height / 2 - 40
	});
	handle.alpha = 0.7;
	// For drag/rotate state
	self.isDragging = false;
	self.isRotating = false;
	self.dragOffsetX = 0;
	self.dragOffsetY = 0;
	self.startAngle = 0;
	self.startRotation = 0;
	// For hit testing
	self.radius = chip.width / 2;
	// Used to distinguish between drag and rotate
	self.down = function (x, y, obj) {
		var local = self.toLocal({
			x: x,
			y: y
		});
		// If touch is on handle, start rotating
		var dx = local.x - handle.x;
		var dy = local.y - handle.y;
		if (dx * dx + dy * dy < handle.width / 2 * (handle.width / 2)) {
			self.isRotating = true;
			// Angle from center to pointer
			var cx = self.x,
				cy = self.y;
			self.startAngle = Math.atan2(y - cy, x - cx);
			self.startRotation = self.rotation;
		} else {
			// Otherwise, start dragging
			self.isDragging = true;
			self.dragOffsetX = x - self.x;
			self.dragOffsetY = y - self.y;
		}
		// Bring to front
		if (self.parent) {
			self.parent.setChildIndex(self, self.parent.children.length - 1);
		}
	};
	self.up = function (x, y, obj) {
		self.isDragging = false;
		self.isRotating = false;
	};
	// No per-chip move handler; handled globally
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x18181b
});

/**** 
* Game Code
****/ 
// --- Icy Tower Constants ---
var highScore = storage.highScore || 0;
var GAME_W = 2048;
var GAME_H = 2732;
var PLATFORM_W = 400;
var PLATFORM_H = 40;
var PLAYER_W = 120;
var PLAYER_H = 120;
var GRAVITY = 2.2;
var JUMP_VELOCITY = -48;
var MOVE_SPEED = 22;
var PLATFORM_SPACING_MIN = 220;
var PLATFORM_SPACING_MAX = 340;
var PLATFORM_X_MARGIN = 120;
var CAMERA_OFFSET = 900; // How far from bottom the player is kept
// --- State ---
var platforms = [];
var player = null;
var vy = 0;
var vx = 0;
var isJumping = false;
var isTouching = false;
var touchStartX = 0;
var cameraY = 0;
var maxHeight = 0;
var gameOver = false;
// --- Assets ---
var playerAsset = LK.getAsset('chipBlue', {
	anchorX: 0.5,
	anchorY: 1,
	scaleX: PLAYER_W / 320,
	scaleY: PLAYER_H / 320
});
// Level themes: background color and platform asset per level
// Platform color is always high-contrast with background for visibility
var LEVEL_THEMES = [{
	bg: 0x18181b,
	platformAsset: 'caseRect',
	platformColor: 0xfacc15 // bright yellow on dark bg
}, {
	bg: 0x1e293b,
	platformAsset: 'chipGreen',
	platformColor: 0xf1f5f9 // white on blue bg
}, {
	bg: 0x312e81,
	platformAsset: 'chipPurple',
	platformColor: 0xfacc15 // yellow on purple bg
}, {
	bg: 0x7c2d12,
	platformAsset: 'chipRed',
	platformColor: 0xf1f5f9 // white on brown bg
}, {
	bg: 0xfbbf24,
	platformAsset: 'chipYellow',
	platformColor: 0x22272b // dark on bright yellow bg
}, {
	bg: 0xf1f5f9,
	platformAsset: 'chipWhite',
	platformColor: 0x22272b // dark on white bg
}];
// Helper to get current theme index based on score/level
function getThemeIndex(score) {
	return Math.floor(score / 100) % LEVEL_THEMES.length;
}
// Helper to get current theme object
function getCurrentTheme(score) {
	return LEVEL_THEMES[getThemeIndex(score)];
}
// Used for initial platform asset (will be replaced in createPlatform)
var platformAsset = LK.getAsset('caseRect', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: PLATFORM_W / 1100,
	scaleY: PLATFORM_H / 700
});
// --- UI ---
// Platform pass counter
var platformsPassed = 0;
// Score text (platforms passed) - top right
var scoreTxt = new Text2('0', {
	size: 90,
	fill: 0xffffff
});
scoreTxt.anchor.set(1, 0); // right aligned
scoreTxt.x = GAME_W - 60;
scoreTxt.y = 60;
LK.gui.top.addChild(scoreTxt);
var highScoreTxt = new Text2('Best: ' + highScore, {
	size: 60,
	fill: 0xfacc15
});
highScoreTxt.anchor.set(1, 0);
highScoreTxt.x = GAME_W - 60;
highScoreTxt.y = 160;
LK.gui.top.addChild(highScoreTxt);
// --- Helper: create a platform at (x, y) ---
function createPlatform(x, y, width) {
	var plat = new Container();
	var w = width || PLATFORM_W;
	// Determine theme based on current score (or maxHeight for new platforms)
	var score = Math.floor(maxHeight / 10) || 0;
	var theme = getCurrentTheme(score);
	var assetId = theme.platformAsset;
	var platformColor = theme.platformColor;
	var platGfx = plat.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: w / 1100,
		scaleY: PLATFORM_H / 700,
		color: platformColor
	});
	plat.x = x;
	plat.y = y;
	plat.width = w;
	plat.height = PLATFORM_H;
	game.addChild(plat);
	platforms.push(plat);
	return plat;
}
// --- Helper: find a safe X for a new platform, given previous platform ---
function getSafePlatformX(prevPlat, width) {
	// Always keep new platform horizontally reachable from previous
	var minX = Math.max(PLATFORM_X_MARGIN + width / 2, prevPlat ? prevPlat.x - 400 : PLATFORM_X_MARGIN + width / 2);
	var maxX = Math.min(GAME_W - PLATFORM_X_MARGIN - width / 2, prevPlat ? prevPlat.x + 400 : GAME_W - PLATFORM_X_MARGIN - width / 2);
	if (minX > maxX) minX = maxX = prevPlat ? prevPlat.x : GAME_W / 2;
	return minX + Math.random() * (maxX - minX);
}
// --- Helper: reset game state ---
function resetGame() {
	// Remove old platforms
	for (var i = 0; i < platforms.length; ++i) {
		platforms[i].destroy();
	}
	platforms = [];
	// Remove player
	if (player) player.destroy();
	// Create player
	player = new Container();
	var pGfx = player.attachAsset('chipBlue', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: PLAYER_W / 320,
		scaleY: PLAYER_H / 320
	});
	player.x = GAME_W / 2;
	player.y = GAME_H - 400;
	player.width = PLAYER_W;
	player.height = PLAYER_H;
	game.addChild(player);
	vy = 0;
	vx = 0;
	isJumping = false;
	isTouching = false;
	cameraY = 0;
	maxHeight = 0;
	gameOver = false;
	// Create initial platforms
	var y = GAME_H - 200;
	// First platform: centered and wide, guaranteed under player
	var firstPlat = createPlatform(GAME_W / 2, y);
	y -= 260; // Consistent spacing for first jump
	// Place player directly above first platform
	player.x = firstPlat.x;
	player.y = firstPlat.y - PLATFORM_H / 2;
	// Make platforms much wider and closer for easy jumps
	var EASY_PLATFORM_W = 820;
	var EASY_PLATFORM_SPACING_MIN = 120;
	var EASY_PLATFORM_SPACING_MAX = 160;
	var prevPlat = firstPlat;
	for (var i = 1; i < 12; ++i) {
		var px = getSafePlatformX(prevPlat, EASY_PLATFORM_W);
		var plat = createPlatform(px, y, EASY_PLATFORM_W);
		plat.width = EASY_PLATFORM_W;
		plat.children[0].scale.x = EASY_PLATFORM_W / 1100;
		prevPlat = plat;
		y -= Math.random() * (EASY_PLATFORM_SPACING_MAX - EASY_PLATFORM_SPACING_MIN) + EASY_PLATFORM_SPACING_MIN;
	}
	// Sort platforms by y
	platforms.sort(function (a, b) {
		return a.y - b.y;
	});
	// Score
	platformsPassed = 0;
	scoreTxt.setText('0');
	highScoreTxt.setText('Best: ' + highScore);
	// Reset theme and background
	game.lastThemeIndex = -1;
	game.setBackgroundColor(LEVEL_THEMES[0].bg);
}
// --- Helper: check collision between player and platform ---
function playerOnPlatform() {
	for (var i = 0; i < platforms.length; ++i) {
		var plat = platforms[i];
		// Only check if player is falling
		if (vy >= 0) {
			var px = player.x;
			var py = player.y;
			var platTop = plat.y - PLATFORM_H / 2;
			var platLeft = plat.x - PLATFORM_W / 2;
			var platRight = plat.x + PLATFORM_W / 2;
			// Check if player's feet are just above platform
			if (py >= platTop && py <= platTop + vy + 8) {
				if (px > platLeft && px < platRight) {
					return plat;
				}
			}
		}
	}
	return null;
}
// --- Touch controls: left/right jump ---
game.down = function (x, y, obj) {
	if (gameOver) return;
	isTouching = true;
	touchStartX = x;
	// If player is on ground/platform, jump
	if (!isJumping) {
		vy = JUMP_VELOCITY;
		// Direction: left or right half of screen
		if (x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
		isJumping = true;
	}
};
game.up = function (x, y, obj) {
	isTouching = false;
	vx = 0;
};
game.move = function (x, y, obj) {
	// Optionally, allow swiping to control direction
	if (isTouching && !gameOver) {
		if (x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
	}
};
// --- Main update loop ---
game.update = function () {
	if (gameOver) return;
	// Physics
	vy += GRAVITY;
	player.x += vx;
	player.y += vy;
	// Clamp player to screen
	if (player.x < PLAYER_W / 2) player.x = PLAYER_W / 2;
	if (player.x > GAME_W - PLAYER_W / 2) player.x = GAME_W - PLAYER_W / 2;
	// Platform collision
	var plat = playerOnPlatform();
	if (plat && vy > 0) {
		player.y = plat.y - PLATFORM_H / 2;
		vy = JUMP_VELOCITY;
		isJumping = false;
	} else {
		isJumping = true;
	}
	// Camera follows player upward
	if (player.y < GAME_H - CAMERA_OFFSET) {
		var diff = GAME_H - CAMERA_OFFSET - player.y;
		cameraY += diff;
		// Move all platforms and player down by diff
		for (var i = 0; i < platforms.length; ++i) {
			platforms[i].y += diff;
		}
		player.y += diff;
		maxHeight += diff;
	}
	// Always keep player in front of platforms
	if (player.parent && player.parent.children.indexOf(player) !== player.parent.children.length - 1) {
		player.parent.setChildIndex(player, player.parent.children.length - 1);
	}
	// Remove platforms that are off screen, add new ones at top
	for (var i = platforms.length - 1; i >= 0; --i) {
		if (platforms[i].y > GAME_H + 100) {
			platforms[i].destroy();
			platforms.splice(i, 1);
			platformsPassed++;
			scoreTxt.setText(platformsPassed.toString());
		}
	}
	// Add new platforms if needed
	while (platforms.length < 12) {
		var topY = platforms[0].y;
		// Use much easier spacing and width for new platforms
		var EASY_PLATFORM_W = 820;
		var EASY_PLATFORM_SPACING_MIN = 120;
		var EASY_PLATFORM_SPACING_MAX = 160;
		var newY = topY - Math.random() * (EASY_PLATFORM_SPACING_MAX - EASY_PLATFORM_SPACING_MIN) - EASY_PLATFORM_SPACING_MIN;
		var prevPlat = platforms[0];
		var px = getSafePlatformX(prevPlat, EASY_PLATFORM_W);
		var plat = createPlatform(px, newY, EASY_PLATFORM_W);
		platforms.sort(function (a, b) {
			return a.y - b.y;
		});
	}
	// Score: based on maxHeight climbed
	var score = Math.floor(maxHeight / 10);
	scoreTxt.setText(score.toString());
	// Level theme logic removed
	// High score logic
	if (score > highScore) {
		highScore = score;
		storage.highScore = highScore;
		highScoreTxt.setText('Best: ' + highScore);
	}
	// Game over: fall below screen
	if (player.y > GAME_H + 200) {
		gameOver = true;
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 800);
	}
};
// --- Start game ---
resetGame();