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

/**** 
* Classes
****/ 
var Letter = Container.expand(function (letterType) {
	var self = Container.call(this);
	self.letterType = letterType || 'A';
	var assetId;
	var textColor = "#FFFFFF";
	switch (self.letterType) {
		case 'A':
			assetId = 'letterA';
			break;
		case 'B':
			assetId = 'letterB';
			break;
		case 'C':
			assetId = 'letterC';
			break;
		default:
			assetId = 'letterA';
	}
	var letterGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.value = self.letterType === 'A' ? 10 : self.letterType === 'B' ? 20 : 30;
	self.addText = function () {
		self.text = new Text2(self.letterType, {
			size: 50,
			fill: textColor
		});
		self.text.anchor.set(0.5, 0.5);
		self.addChild(self.text);
	};
	self.collected = function () {
		// Animation for being collected
		tween(self, {
			alpha: 0,
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: .5,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	self.update = function () {
		// Letters can have simple wandering behavior
		if (Math.random() < 0.02 && !gameOver) {
			self.x += Math.random() * 6 - 3;
			self.y += Math.random() * 6 - 3;
			// Keep in bounds
			self.x = Math.max(50, Math.min(self.x, 2048 - 50));
			self.y = Math.max(50, Math.min(self.y, 2732 - 50));
		}
	};
	self.addText();
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.direction = Math.random() * Math.PI * 2;
	self.speed = 2 + Math.random() * 2;
	self.update = function () {
		if (gameOver) {
			return;
		}
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
		// Bounce off edges
		if (self.x < 60) {
			self.x = 60;
			self.direction = Math.PI - self.direction;
		} else if (self.x > 2048 - 60) {
			self.x = 2048 - 60;
			self.direction = Math.PI - self.direction;
		}
		if (self.y < 60) {
			self.y = 60;
			self.direction = -self.direction;
		} else if (self.y > 2732 - 60) {
			self.y = 2732 - 60;
			self.direction = -self.direction;
		}
		// Rotate the obstacle
		obstacleGraphics.rotation += 0.01;
	};
	// Add X text to make it clear it's an obstacle
	self.text = new Text2('X', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('letterF', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.size = 100;
	self.isMoving = false;
	self.isDragging = false;
	self.hasPowerup = false;
	self.powerupTimer = null;
	self.addText = function () {
		self.text = new Text2('F', {
			size: 60,
			fill: 0xFFFFFF
		});
		self.text.anchor.set(0.5, 0.5);
		self.addChild(self.text);
	};
	self.activatePowerup = function (type) {
		self.hasPowerup = true;
		// Clear any existing powerup timer
		if (self.powerupTimer) {
			LK.clearTimeout(self.powerupTimer);
		}
		if (type === 'speed') {
			self.speed = 20;
			playerGraphics.tint = 0xffcc00;
		} else if (type === 'magnet') {
			playerGraphics.tint = 0x00ccff;
		} else if (type === 'size') {
			tween(playerGraphics, {
				width: 130,
				height: 130
			}, {
				duration: 300
			});
			if (self.text) {
				tween(self.text, {
					size: 78
				}, {
					duration: 300
				});
			}
		}
		// Set timeout to reset powerup
		self.powerupTimer = LK.setTimeout(function () {
			self.deactivatePowerup();
		}, 5000);
	};
	self.deactivatePowerup = function () {
		self.hasPowerup = false;
		self.speed = 10;
		playerGraphics.tint = 0xFFFFFF;
		tween(playerGraphics, {
			width: 100,
			height: 100
		}, {
			duration: 300
		});
		if (self.text) {
			tween(self.text, {
				size: 60
			}, {
				duration: 300
			});
		}
	};
	self.update = function () {
		if (self.targetX !== undefined && self.targetY !== undefined) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.speed) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
				self.isMoving = true;
			} else {
				self.x = self.targetX;
				self.y = self.targetY;
				self.targetX = undefined;
				self.targetY = undefined;
				self.isMoving = false;
			}
		}
	};
	self.moveTo = function (x, y) {
		self.targetX = x;
		self.targetY = y;
	};
	self.addText();
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'speed';
	var powerupGraphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (self.type === 'speed') {
		powerupGraphics.tint = 0xffcc00; // Yellow for speed
	} else if (self.type === 'magnet') {
		powerupGraphics.tint = 0x00ccff; // Blue for magnet
	} else if (self.type === 'size') {
		powerupGraphics.tint = 0xff00cc; // Pink for size
	}
	self.pulseDirection = 1;
	self.pulseAmount = 0;
	self.update = function () {
		// Make the powerup pulse
		self.pulseAmount += 0.03 * self.pulseDirection;
		if (self.pulseAmount > 1) {
			self.pulseAmount = 1;
			self.pulseDirection = -1;
		} else if (self.pulseAmount < 0) {
			self.pulseAmount = 0;
			self.pulseDirection = 1;
		}
		var scale = 1 + self.pulseAmount * 0.2;
		self.scale.set(scale, scale);
		// Make powerups disappear after some time
		if (self.timeAlive === undefined) {
			self.timeAlive = 0;
		} else {
			self.timeAlive++;
			if (self.timeAlive > 600) {
				// 10 seconds at 60fps
				tween(self, {
					alpha: 0
				}, {
					duration: 500,
					onFinish: function onFinish() {
						self.destroy();
					}
				});
			}
		}
	};
	self.collected = function () {
		tween(self, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: 500,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var player;
var letters = [];
var obstacles = [];
var powerups = [];
var level = 1;
var gameOver = false;
var letterSpawnTimer;
var obstacleSpawnTimer;
var powerupSpawnTimer;
var levelTimer;
var scoreTxt;
var levelTxt;
// Initialize game
function initGame() {
	// Clear any existing timers
	if (letterSpawnTimer) {
		LK.clearInterval(letterSpawnTimer);
	}
	if (obstacleSpawnTimer) {
		LK.clearInterval(obstacleSpawnTimer);
	}
	if (powerupSpawnTimer) {
		LK.clearInterval(powerupSpawnTimer);
	}
	if (levelTimer) {
		LK.clearTimeout(levelTimer);
	}
	// Reset game state
	gameOver = false;
	level = 1;
	letters = [];
	obstacles = [];
	powerups = [];
	LK.setScore(0);
	// Create player
	player = new Player();
	player.x = 2048 / 2;
	player.y = 2732 / 2;
	game.addChild(player);
	// Create UI
	createUI();
	// Start spawning letters
	startSpawning();
	// Play background music
	LK.playMusic('bgMusic');
}
function createUI() {
	// Score text
	scoreTxt = new Text2('Score: 0', {
		size: 80,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreTxt);
	scoreTxt.y = 30;
	// Level text
	levelTxt = new Text2('Level: 1', {
		size: 60,
		fill: 0xFFFFFF
	});
	levelTxt.anchor.set(0.5, 0);
	levelTxt.y = 120;
	LK.gui.top.addChild(levelTxt);
}
function startSpawning() {
	// Clear any existing timers
	if (letterSpawnTimer) {
		LK.clearInterval(letterSpawnTimer);
	}
	if (obstacleSpawnTimer) {
		LK.clearInterval(obstacleSpawnTimer);
	}
	if (powerupSpawnTimer) {
		LK.clearInterval(powerupSpawnTimer);
	}
	// Spawn letters
	letterSpawnTimer = LK.setInterval(function () {
		if (letters.length < 5 + level) {
			spawnLetter();
		}
	}, 2000 - level * 100);
	// Spawn obstacles
	obstacleSpawnTimer = LK.setInterval(function () {
		if (obstacles.length < level) {
			spawnObstacle();
		}
	}, 5000 - level * 200);
	// Spawn powerups (less frequently)
	powerupSpawnTimer = LK.setInterval(function () {
		if (Math.random() < 0.3 && powerups.length < 2) {
			spawnPowerup();
		}
	}, 10000);
	// Set timer for next level
	levelTimer = LK.setTimeout(function () {
		if (!gameOver) {
			level++;
			levelTxt.setText('Level: ' + level);
			startSpawning(); // Restart spawning with new level settings
		}
	}, 30000); // Level up every 30 seconds
}
function spawnLetter() {
	var letterType;
	var rand = Math.random();
	if (rand < 0.5) {
		letterType = 'A';
	} else if (rand < 0.8) {
		letterType = 'B';
	} else {
		letterType = 'C';
	}
	var letter = new Letter(letterType);
	// Position randomly but not too close to player or other letters
	var validPosition = false;
	var attempts = 0;
	var x, y;
	while (!validPosition && attempts < 10) {
		x = 100 + Math.random() * (2048 - 200);
		y = 100 + Math.random() * (2732 - 200);
		// Check distance from player
		var distToPlayer = Math.sqrt(Math.pow(x - player.x, 2) + Math.pow(y - player.y, 2));
		validPosition = distToPlayer > 300;
		// Check distance from other letters
		for (var i = 0; i < letters.length; i++) {
			var distToLetter = Math.sqrt(Math.pow(x - letters[i].x, 2) + Math.pow(y - letters[i].y, 2));
			if (distToLetter < 200) {
				validPosition = false;
				break;
			}
		}
		attempts++;
	}
	letter.x = x;
	letter.y = y;
	game.addChild(letter);
	letters.push(letter);
}
function spawnObstacle() {
	var obstacle = new Obstacle();
	// Position at the edge of the screen
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			obstacle.x = Math.random() * 2048;
			obstacle.y = 0;
			obstacle.direction = Math.PI / 2 + (Math.random() * Math.PI / 4 - Math.PI / 8);
			break;
		case 1:
			// Right
			obstacle.x = 2048;
			obstacle.y = Math.random() * 2732;
			obstacle.direction = Math.PI + (Math.random() * Math.PI / 4 - Math.PI / 8);
			break;
		case 2:
			// Bottom
			obstacle.x = Math.random() * 2048;
			obstacle.y = 2732;
			obstacle.direction = Math.PI * 3 / 2 + (Math.random() * Math.PI / 4 - Math.PI / 8);
			break;
		case 3:
			// Left
			obstacle.x = 0;
			obstacle.y = Math.random() * 2732;
			obstacle.direction = Math.random() * Math.PI / 4 - Math.PI / 8;
			break;
	}
	game.addChild(obstacle);
	obstacles.push(obstacle);
}
function spawnPowerup() {
	var types = ['speed', 'magnet', 'size'];
	var type = types[Math.floor(Math.random() * types.length)];
	var powerup = new PowerUp(type);
	powerup.x = 100 + Math.random() * (2048 - 200);
	powerup.y = 100 + Math.random() * (2732 - 200);
	game.addChild(powerup);
	powerups.push(powerup);
}
function checkCollisions() {
	// Check letter collisions
	for (var i = letters.length - 1; i >= 0; i--) {
		if (player.intersects(letters[i])) {
			// Player ate a letter
			LK.getSound('munch').play();
			LK.setScore(LK.getScore() + letters[i].value);
			scoreTxt.setText('Score: ' + LK.getScore());
			letters[i].collected();
			letters.splice(i, 1);
		} else if (player.hasPowerup && player.hasPowerup === 'magnet') {
			// Magnet powerup pulls letters closer
			var dx = player.x - letters[i].x;
			var dy = player.y - letters[i].y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < 400) {
				letters[i].x += dx * 0.05;
				letters[i].y += dy * 0.05;
			}
		}
	}
	// Check obstacle collisions
	for (var j = obstacles.length - 1; j >= 0; j--) {
		if (player.intersects(obstacles[j])) {
			// Player hit an obstacle
			LK.getSound('hit').play();
			LK.effects.flashScreen(0xFF0000, 500);
			// Game over
			gameOver = true;
			LK.showGameOver();
			break;
		}
	}
	// Check powerup collisions
	for (var k = powerups.length - 1; k >= 0; k--) {
		if (player.intersects(powerups[k])) {
			// Player got a powerup
			LK.getSound('powerup').play();
			player.activatePowerup(powerups[k].type);
			powerups[k].collected();
			powerups.splice(k, 1);
		}
	}
}
// Event handlers
game.down = function (x, y, obj) {
	player.moveTo(x, y);
};
game.up = function (x, y, obj) {
	// Optional: stop player when released
};
game.move = function (x, y, obj) {
	if (player.isDragging) {
		player.moveTo(x, y);
	}
};
// Game update function
game.update = function () {
	if (gameOver) {
		return;
	}
	// Update player
	if (player) {
		player.update();
	}
	// Update letters
	for (var i = 0; i < letters.length; i++) {
		if (letters[i] && letters[i].update) {
			letters[i].update();
		}
	}
	// Update obstacles
	for (var j = 0; j < obstacles.length; j++) {
		if (obstacles[j] && obstacles[j].update) {
			obstacles[j].update();
		}
	}
	// Update powerups
	for (var k = 0; k < powerups.length; k++) {
		if (powerups[k] && powerups[k].update) {
			powerups[k].update();
		}
	}
	// Check collisions
	checkCollisions();
};
// Initialize the game when everything is loaded
initGame();