/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0,
	level: 1
});

/**** 
* Classes
****/ 
var Asteroid = Container.expand(function () {
	var self = Container.call(this);
	var asteroidGraphics = self.attachAsset('asteroid', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5 + Math.random() * 3;
	self.rotationSpeed = (Math.random() - 0.5) * 0.1;
	self.size = 0.6 + Math.random() * 0.8;
	asteroidGraphics.scale.set(self.size, self.size);
	self.update = function () {
		self.y += self.speed;
		self.rotation += self.rotationSpeed;
		// If asteroid goes off screen, remove it
		if (self.y > 2732 + 100) {
			self.destroyed = true;
		}
	};
	return self;
});
var Boss = Container.expand(function () {
	var self = Container.call(this);
	var bossGraphics = self.attachAsset('boss', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 10;
	self.speed = 1.5;
	self.state = 'entering'; // entering, attacking, exiting
	self.attackTimer = 0;
	self.moveDirection = 1;
	self.points = 2000;
	self.update = function () {
		if (self.state === 'entering') {
			self.y += self.speed;
			if (self.y >= 300) {
				self.state = 'attacking';
			}
		} else if (self.state === 'attacking') {
			// Move side to side
			self.x += self.speed * 2 * self.moveDirection;
			// Reverse direction at screen edges
			if (self.x < 400 || self.x > 2048 - 400) {
				self.moveDirection *= -1;
			}
			// Attack logic
			self.attackTimer++;
			if (self.attackTimer >= 60) {
				// Spawn enemy
				if (Math.random() < 0.5) {
					var enemy = new Enemy();
					enemy.x = self.x + (Math.random() - 0.5) * 200;
					enemy.y = self.y + 100;
					game.enemies.push(enemy);
					game.addChild(enemy);
				}
				self.attackTimer = 0;
			}
		} else if (self.state === 'exiting') {
			self.y -= self.speed * 2;
			if (self.y < -300) {
				self.destroyed = true;
			}
		}
	};
	self.damage = function () {
		self.health--;
		LK.effects.flashObject(self, 0xffffff, 300);
		if (self.health <= 0) {
			self.state = 'exiting';
		}
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.update = function () {
		self.y -= self.speed;
		// If bullet goes off screen, remove it
		if (self.y < -100) {
			self.destroyed = true;
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4 + Math.random() * 2;
	self.horizontalSpeed = (Math.random() - 0.5) * 4;
	self.points = 100;
	self.update = function () {
		self.y += self.speed;
		self.x += self.horizontalSpeed;
		// Bounce off walls
		if (self.x < 100 || self.x > 2048 - 100) {
			self.horizontalSpeed *= -1;
		}
		// If enemy goes off screen, remove it
		if (self.y > 2732 + 100) {
			self.destroyed = true;
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.shieldActive = false;
	self.shieldGraphics = null;
	self.bulletTimer = 0;
	self.canShoot = false;
	self.invulnerable = false;
	self.activateShield = function (duration) {
		if (self.shieldActive) {
			return;
		}
		self.shieldActive = true;
		self.shieldGraphics = self.attachAsset('shield', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.5
		});
		LK.setTimeout(function () {
			if (self.shieldGraphics) {
				self.shieldGraphics.destroy();
				self.shieldGraphics = null;
			}
			self.shieldActive = false;
		}, duration);
	};
	self.activateWeapon = function (duration) {
		self.canShoot = true;
		LK.setTimeout(function () {
			self.canShoot = false;
		}, duration);
	};
	self.makeInvulnerable = function (duration) {
		self.invulnerable = true;
		// Flash effect to show invulnerability
		var flashCount = 0;
		var flashInterval = LK.setInterval(function () {
			playerGraphics.alpha = playerGraphics.alpha === 1 ? 0.3 : 1;
			flashCount++;
			if (flashCount > 10) {
				LK.clearInterval(flashInterval);
				playerGraphics.alpha = 1;
			}
		}, 150);
		LK.setTimeout(function () {
			self.invulnerable = false;
			playerGraphics.alpha = 1;
			LK.clearInterval(flashInterval);
		}, duration);
	};
	self.shoot = function () {
		if (!self.canShoot) {
			return;
		}
		if (self.bulletTimer <= 0) {
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y - 50;
			game.bullets.push(bullet);
			game.addChild(bullet);
			LK.getSound('shoot').play();
			self.bulletTimer = 10; // Rate of fire control
		}
	};
	self.update = function () {
		if (self.bulletTimer > 0) {
			self.bulletTimer--;
		}
		if (self.canShoot) {
			self.shoot();
		}
		if (self.shieldGraphics) {
			self.shieldGraphics.rotation += 0.02;
		}
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var type = Math.floor(Math.random() * 3); // 0: shield, 1: weapon, 2: speed
	var colors = [0x2ecc71, 0xf1c40f, 0x9b59b6];
	var powerupGraphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: colors[type]
	});
	self.type = type;
	self.speed = 3;
	self.update = function () {
		self.y += self.speed;
		self.rotation += 0.02;
		// If powerup goes off screen, remove it
		if (self.y > 2732 + 100) {
			self.destroyed = true;
		}
	};
	return self;
});
var Star = Container.expand(function () {
	var self = Container.call(this);
	var brightness = 0.3 + Math.random() * 0.7;
	var starGraphics = self.attachAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: brightness
	});
	self.speed = 1 + Math.random() * 3;
	self.update = function () {
		self.y += self.speed;
		// If star goes off screen, reset to top
		if (self.y > 2732 + 50) {
			self.y = -50;
			self.x = Math.random() * 2048;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var player;
var score = 0;
var level = storage.level || 1;
var highScore = storage.highScore || 0;
var gameActive = true;
var dragNode = null;
var spawnTimer = 0;
var difficultyTimer = 0;
var bossSpawnLevel = 5;
var currentBoss = null;
var spawnRate = 100;
var scoreDisplay;
var levelDisplay;
var stars = [];
// Collection arrays
game.asteroids = [];
game.enemies = [];
game.powerups = [];
game.bullets = [];
// Initialize player
function initPlayer() {
	player = new Player();
	player.x = 2048 / 2;
	player.y = 2732 - 250;
	game.addChild(player);
	// Start with brief invulnerability
	player.makeInvulnerable(2000);
}
// Initialize stars background
function initStars() {
	for (var i = 0; i < 50; i++) {
		var star = new Star();
		star.x = Math.random() * 2048;
		star.y = Math.random() * 2732;
		stars.push(star);
		game.addChild(star);
	}
}
// Initialize UI
function initUI() {
	// Score display
	scoreDisplay = new Text2('Score: 0', {
		size: 80,
		fill: 0xFFFFFF
	});
	scoreDisplay.anchor.set(0, 0);
	LK.gui.topRight.addChild(scoreDisplay);
	// Level display
	levelDisplay = new Text2('Level: ' + level, {
		size: 80,
		fill: 0xFFFFFF
	});
	levelDisplay.anchor.set(0, 0);
	LK.gui.topRight.addChild(levelDisplay);
	levelDisplay.y = 100;
	// High score display
	var highScoreDisplay = new Text2('High Score: ' + highScore, {
		size: 60,
		fill: 0xFFFF00
	});
	highScoreDisplay.anchor.set(0, 0);
	LK.gui.topRight.addChild(highScoreDisplay);
	highScoreDisplay.y = 200;
}
// Update score
function updateScore(points) {
	score += points;
	scoreDisplay.setText('Score: ' + score);
	// Check for high score
	if (score > highScore) {
		highScore = score;
		storage.highScore = highScore;
	}
	LK.setScore(score);
}
// Spawn asteroid
function spawnAsteroid() {
	var asteroid = new Asteroid();
	asteroid.x = Math.random() * 2048;
	asteroid.y = -100;
	game.asteroids.push(asteroid);
	game.addChild(asteroid);
}
// Spawn enemy
function spawnEnemy() {
	var enemy = new Enemy();
	enemy.x = Math.random() * 2048;
	enemy.y = -100;
	game.enemies.push(enemy);
	game.addChild(enemy);
}
// Spawn powerup
function spawnPowerup() {
	var powerup = new PowerUp();
	powerup.x = Math.random() * 2048;
	powerup.y = -100;
	game.powerups.push(powerup);
	game.addChild(powerup);
}
// Spawn boss
function spawnBoss() {
	currentBoss = new Boss();
	currentBoss.x = 2048 / 2;
	currentBoss.y = -300;
	game.addChild(currentBoss);
	LK.getSound('boss_arrival').play();
	LK.effects.flashScreen(0xff0000, 500);
}
// Check collision between two objects
function checkCollision(obj1, obj2) {
	return obj1.intersects(obj2);
}
// Handle player collision with obstacle
function handlePlayerCollision() {
	if (player.invulnerable) {
		return false;
	}
	if (player.shieldActive) {
		// Shield absorbs one hit
		player.shieldActive = false;
		if (player.shieldGraphics) {
			player.shieldGraphics.destroy();
			player.shieldGraphics = null;
		}
		LK.effects.flashObject(player, 0x2ecc71, 500);
		return false;
	}
	// Player hit - game over
	LK.effects.flashScreen(0xff0000, 1000);
	LK.getSound('explosion').play();
	gameActive = false;
	// Store level progress
	storage.level = level;
	// Show game over after a short delay
	LK.setTimeout(function () {
		LK.showGameOver();
	}, 1200);
	return true;
}
// Apply powerup effect
function applyPowerup(type) {
	switch (type) {
		case 0:
			// Shield
			player.activateShield(10000);
			break;
		case 1:
			// Weapon
			player.activateWeapon(8000);
			break;
		case 2:
			// Speed boost
			player.makeInvulnerable(5000);
			break;
	}
	LK.getSound('powerup_collect').play();
}
// Level up
function levelUp() {
	level++;
	levelDisplay.setText('Level: ' + level);
	// Speed up spawning as levels increase
	spawnRate = Math.max(30, 100 - level * 5);
	// Show level up indicator
	var levelUpText = new Text2('LEVEL ' + level, {
		size: 150,
		fill: 0xFFFF00
	});
	levelUpText.anchor.set(0.5, 0.5);
	levelUpText.x = 2048 / 2;
	levelUpText.y = 2732 / 2;
	game.addChild(levelUpText);
	// Animate level up text
	tween(levelUpText, {
		alpha: 0,
		scaleX: 2,
		scaleY: 2
	}, {
		duration: 1500,
		onFinish: function onFinish() {
			levelUpText.destroy();
		}
	});
	// Check if it's a boss level
	if (level % bossSpawnLevel === 0) {
		spawnBoss();
	}
}
// Handle player movement
function handleMove(x, y) {
	if (!gameActive || !dragNode) {
		return;
	}
	// Constrain player to screen bounds
	var boundedX = Math.max(100, Math.min(2048 - 100, x));
	var boundedY = Math.max(100, Math.min(2732 - 100, y));
	dragNode.x = boundedX;
	dragNode.y = boundedY;
}
// Mouse or touch events
game.down = function (x, y) {
	if (!gameActive) {
		return;
	}
	dragNode = player;
	handleMove(x, y);
};
game.move = function (x, y) {
	handleMove(x, y);
};
game.up = function () {
	dragNode = null;
};
// Initialize game
function initGame() {
	// Play background music
	LK.playMusic('game_music');
	// Initialize game components
	initStars();
	initPlayer();
	initUI();
	// Reset game state
	gameActive = true;
	score = 0;
	updateScore(0);
}
// Initialize the game
initGame();
// Game update loop
game.update = function () {
	if (!gameActive) {
		return;
	}
	// Update difficulty over time
	difficultyTimer++;
	if (difficultyTimer >= 1800) {
		// 30 seconds
		difficultyTimer = 0;
		levelUp();
	}
	// Spawn objects
	spawnTimer++;
	if (spawnTimer >= spawnRate) {
		spawnTimer = 0;
		// Determine what to spawn based on probability
		var rand = Math.random();
		if (rand < 0.6) {
			spawnAsteroid();
		} else if (rand < 0.9) {
			spawnEnemy();
		} else {
			spawnPowerup();
		}
	}
	// Update stars
	for (var i = 0; i < stars.length; i++) {
		stars[i].update();
	}
	// Update player
	if (player) {
		player.update();
	}
	// Update boss
	if (currentBoss) {
		currentBoss.update();
		if (currentBoss.destroyed) {
			// Award points when boss is defeated
			updateScore(currentBoss.points);
			currentBoss = null;
		}
	}
	// Update asteroids
	for (var a = game.asteroids.length - 1; a >= 0; a--) {
		var asteroid = game.asteroids[a];
		asteroid.update();
		// Check for collision with player
		if (player && checkCollision(player, asteroid)) {
			if (handlePlayerCollision()) {
				break; // Game over, stop checking collisions
			}
			// Remove asteroid after collision
			asteroid.destroy();
			game.asteroids.splice(a, 1);
			continue;
		}
		// Remove if marked as destroyed
		if (asteroid.destroyed) {
			asteroid.destroy();
			game.asteroids.splice(a, 1);
		}
	}
	// Update enemies
	for (var e = game.enemies.length - 1; e >= 0; e--) {
		var enemy = game.enemies[e];
		enemy.update();
		// Check for collision with player
		if (player && checkCollision(player, enemy)) {
			if (handlePlayerCollision()) {
				break; // Game over, stop checking collisions
			}
			// Remove enemy after collision
			enemy.destroy();
			game.enemies.splice(e, 1);
			continue;
		}
		// Remove if marked as destroyed
		if (enemy.destroyed) {
			enemy.destroy();
			game.enemies.splice(e, 1);
		}
	}
	// Update powerups
	for (var p = game.powerups.length - 1; p >= 0; p--) {
		var powerup = game.powerups[p];
		powerup.update();
		// Check for collision with player
		if (player && checkCollision(player, powerup)) {
			applyPowerup(powerup.type);
			powerup.destroy();
			game.powerups.splice(p, 1);
			// Award points for collecting powerup
			updateScore(50);
			continue;
		}
		// Remove if marked as destroyed
		if (powerup.destroyed) {
			powerup.destroy();
			game.powerups.splice(p, 1);
		}
	}
	// Update bullets
	for (var b = game.bullets.length - 1; b >= 0; b--) {
		var bullet = game.bullets[b];
		bullet.update();
		var hitSomething = false;
		// Check for collision with enemies
		for (var e2 = game.enemies.length - 1; e2 >= 0; e2--) {
			var enemy2 = game.enemies[e2];
			if (checkCollision(bullet, enemy2)) {
				// Remove enemy
				enemy2.destroy();
				game.enemies.splice(e2, 1);
				// Award points
				updateScore(enemy2.points);
				hitSomething = true;
				LK.getSound('explosion').play();
				break;
			}
		}
		// Check for collision with asteroids
		if (!hitSomething) {
			for (var a2 = game.asteroids.length - 1; a2 >= 0; a2--) {
				var asteroid2 = game.asteroids[a2];
				if (checkCollision(bullet, asteroid2)) {
					// Remove asteroid
					asteroid2.destroy();
					game.asteroids.splice(a2, 1);
					// Award points
					updateScore(50);
					hitSomething = true;
					LK.getSound('explosion').play();
					break;
				}
			}
		}
		// Check for collision with boss
		if (!hitSomething && currentBoss && checkCollision(bullet, currentBoss)) {
			currentBoss.damage();
			hitSomething = true;
		}
		// Remove bullet if it hit something or went off-screen
		if (hitSomething || bullet.destroyed) {
			bullet.destroy();
			game.bullets.splice(b, 1);
		}
	}
	// Survive points (small increment every second)
	if (LK.ticks % 60 === 0) {
		updateScore(1);
	}
};