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

/**** 
* Classes
****/ 
var Balloon = Container.expand(function (type, speed, value) {
	var self = Container.call(this);
	self.type = type || 'red';
	self.speed = speed || 3;
	self.value = value || 10;
	self.popped = false;
	// Determine balloon color and behavior based on type
	var balloonColor = 'balloon_red'; // Default to red if type is not recognized
	if (self.type === 'red') {
		balloonColor = 'balloon_red';
	} else if (self.type === 'green') {
		balloonColor = 'balloon_green';
	} else if (self.type === 'blue') {
		balloonColor = 'balloon_blue';
	} else if (self.type === 'yellow') {
		balloonColor = 'balloon_yellow';
	} else if (self.type === 'purple') {
		balloonColor = 'balloon_purple';
	} else if (self.type === 'slow') {
		balloonColor = 'powerup_slow';
		self.isPowerup = true;
		self.powerupType = 'slow';
	} else if (self.type === 'double') {
		balloonColor = 'powerup_double';
		self.isPowerup = true;
		self.powerupType = 'double';
	} else if (self.type === 'freeze') {
		balloonColor = 'powerup_freeze';
		self.isPowerup = true;
		self.powerupType = 'freeze';
	}
	// Create balloon body
	self.body = self.attachAsset(balloonColor, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Only add strings to regular balloons, not powerups
	if (!self.isPowerup) {
		// Add balloon string
		self.string = self.attachAsset('balloon_string', {
			anchorX: 0.5,
			anchorY: 0
		});
		self.string.y = self.body.height / 2;
	}
	// Interactive elements need to be flagged as such
	self.body.interactive = true;
	// Event handler for popping balloon
	self.down = function (x, y, obj) {
		if (!self.popped && !gameOver && !gamePaused) {
			self.pop();
		}
	};
	// Pop the balloon
	self.pop = function () {
		if (self.popped) {
			return;
		}
		self.popped = true;
		// Play pop sound for any balloon
		LK.getSound('pop').play();
		// Check if this is a good or bad balloon
		if (self.type === 'red' || self.type === 'green' || self.type === 'blue') {
			// Good balloon - add points
			LK.setScore(LK.getScore() + self.value * pointMultiplier);
			// Play additional sound effect for enhanced audio feedback
			LK.getSound('pop_extra').play();
			LK.getSound('elenme').play();
			// Play additional sound effect for enhanced audio feedback
			LK.getSound('pop_extra').play();
			// Flash balloon white before removing
			LK.effects.flashObject(self, 0xffffff, 300);
			// Add needle effect for visual enhancement
			createNeedleEffect(self.x, self.y, {
				color: 0xffffff,
				size: 10
			});
		} else if (self.type === 'yellow' || self.type === 'purple' || self.type === 'bomb') {
			// Bad balloon or bomb - subtract points
			LK.setScore(Math.max(0, LK.getScore() - self.value));
			LK.getSound('bad_pop').play();
			LK.getSound('elenmess').play();
			// Flash balloon red before removing
			LK.effects.flashObject(self, 0xff0000, 300);
		} else if (self.isPowerup) {
			// Powerup balloon
			LK.getSound('powerup').play();
			// Flash balloon white
			LK.effects.flashObject(self, 0xffffff, 300);
			// Apply powerup effect
			if (self.powerupType === 'slow') {
				gameSpeed = 0.5;
				// Reset game speed after 5 seconds
				LK.setTimeout(function () {
					gameSpeed = 1;
				}, 5000);
			} else if (self.powerupType === 'double') {
				pointMultiplier = 2;
				// Reset point multiplier after 5 seconds
				LK.setTimeout(function () {
					pointMultiplier = 1;
				}, 5000);
			} else if (self.powerupType === 'freeze') {
				freezeMode = true;
				// Reset freeze mode after 3 seconds
				LK.setTimeout(function () {
					freezeMode = false;
				}, 3000);
			}
		}
		// Update score display
		updateScoreDisplay();
		// Remove balloon after short delay to allow for flash effect
		LK.setTimeout(function () {
			self.visible = false;
			// Find balloon in array and remove it
			var balloonIndex = balloons.indexOf(self);
			if (balloonIndex !== -1) {
				balloons.splice(balloonIndex, 1);
				self.destroy();
			}
		}, 300);
	};
	self.update = function () {
		if (self.popped) {
			return;
		}
		// Don't move if game is in freeze mode
		if (freezeMode) {
			return;
		}
		// Move balloon upward
		self.y -= self.speed * gameSpeed;
		// Remove balloon if it goes off the top of the screen
		if (self.y < -200) {
			var balloonIndex = balloons.indexOf(self);
			if (balloonIndex !== -1) {
				balloons.splice(balloonIndex, 1);
				self.destroy();
				// Penalty for missing good balloons
				if (self.type === 'red' || self.type === 'green' || self.type === 'blue') {
					LK.setScore(Math.max(0, LK.getScore() - Math.floor(self.value / 2)));
					updateScoreDisplay();
				}
			}
		}
	};
	return self;
});
var PowerupIndicator = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type;
	// Create indicator shape
	var indicatorAsset;
	if (self.type === 'slow') {
		indicatorAsset = 'powerup_slow';
	} else if (self.type === 'double') {
		indicatorAsset = 'powerup_double';
	} else if (self.type === 'freeze') {
		indicatorAsset = 'powerup_freeze';
	}
	self.indicator = self.attachAsset(indicatorAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.timeRemaining = 0;
	self.active = false;
	self.activate = function (duration) {
		self.timeRemaining = duration;
		self.active = true;
		self.alpha = 1;
		// Add visual effect for power-up activation
		LK.effects.flashObject(self, 0x00ff00, 500);
	};
	self.update = function () {
		if (self.active) {
			self.timeRemaining -= 16.67; // Approximate ms per frame at 60fps
			if (self.timeRemaining <= 0) {
				self.active = false;
				self.alpha = 0.3;
			}
		}
	};
	// Initial state is inactive
	self.alpha = 0.3;
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
function createNeedleEffect(x, y, options) {
	var needle = new Container();
	var needleGraphics = LK.getAsset('needle', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: options.size / 100,
		scaleY: options.size / 100,
		tint: options.color
	});
	needle.addChild(needleGraphics);
	needle.x = x;
	needle.y = y;
	game.addChild(needle);
	// Animate the needle effect
	tween(needle, {
		alpha: 0
	}, {
		duration: 300,
		onFinish: function onFinish() {
			needle.destroy();
		}
	});
}
var balloons = [];
var spawnInterval;
var levelTimers = [];
var currentLevel = storage.level || 1;
var gameOver = false;
var gamePaused = false;
var gameSpeed = 1;
var pointMultiplier = 1;
var freezeMode = false;
var lastSpawnTime = 0;
var spawnDelay = 1000; // starting spawn delay
// UI elements
var scoreTxt;
var levelTxt;
var highScoreTxt;
var powerupIndicators = {};
// Initialize game elements
function initGame() {
	// Clear any existing balloons
	while (balloons.length > 0) {
		balloons[0].destroy();
		balloons.splice(0, 1);
	}
	// Clear any existing timers
	if (spawnInterval) {
		LK.clearInterval(spawnInterval);
	}
	levelTimers.forEach(function (timer) {
		LK.clearTimeout(timer);
	});
	levelTimers = [];
	// Reset game state
	gameOver = false;
	gamePaused = false;
	gameSpeed = 1;
	pointMultiplier = 1;
	freezeMode = false;
	// Setup UI
	setupUI();
	// Start balloon spawning
	spawnInterval = LK.setInterval(spawnBalloon, spawnDelay);
	// Play background music with enhanced fade-in effect
	LK.playMusic('bgmusic', {
		fade: {
			start: 0,
			end: 0.7,
			duration: 2000
		}
	});
	// Set level based difficulty
	setupLevelDifficulty();
}
// Create UI elements
function setupUI() {
	// Score display
	scoreTxt = new Text2('Score: 0', {
		size: 70,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreTxt);
	scoreTxt.y = 20;
	// Level display
	levelTxt = new Text2('Level: ' + currentLevel, {
		size: 50,
		fill: 0xFFFFFF
	});
	levelTxt.anchor.set(0, 0);
	LK.gui.topRight.addChild(levelTxt);
	levelTxt.x = -180;
	levelTxt.y = 20;
	// High score display
	highScoreTxt = new Text2('Best: ' + storage.highScore, {
		size: 40,
		fill: 0xFFFFFF
	});
	highScoreTxt.anchor.set(0, 0);
	LK.gui.topRight.addChild(highScoreTxt);
	highScoreTxt.x = -180;
	highScoreTxt.y = 80;
	// Powerup indicators
	setupPowerupIndicators();
	// Update displays
	updateScoreDisplay();
}
// Setup powerup indicators
function setupPowerupIndicators() {
	// Create indicators for each powerup type
	var types = ['slow', 'double', 'freeze'];
	var startX = 130;
	types.forEach(function (type, index) {
		var indicator = new PowerupIndicator(type);
		powerupIndicators[type] = indicator;
		LK.gui.bottomLeft.addChild(indicator);
		indicator.x = startX + index * 120;
		indicator.y = -100;
	});
}
// Update score display
function updateScoreDisplay() {
	scoreTxt.setText('Score: ' + LK.getScore());
	// Update high score if needed
	if (LK.getScore() > storage.highScore) {
		storage.highScore = LK.getScore();
		highScoreTxt.setText('Best: ' + storage.highScore);
	}
}
// Set up difficulty based on current level
function setupLevelDifficulty() {
	// Adjust spawn delay based on level
	spawnDelay = Math.max(300, 1000 - currentLevel * 100);
	// Clear and set new spawn interval
	if (spawnInterval) {
		LK.clearInterval(spawnInterval);
	}
	spawnInterval = LK.setInterval(spawnBalloon, spawnDelay);
	// Update level display
	levelTxt.setText('Level: ' + currentLevel);
	// Schedule level up if not at max level
	if (currentLevel < 5) {
		var levelTimer = LK.setTimeout(function () {
			levelUp();
		}, 30000); // Level up every 30 seconds
		levelTimers.push(levelTimer);
	}
}
// Level up function
function levelUp() {
	currentLevel++;
	storage.level = currentLevel;
	// Display level up message
	var levelUpText = new Text2('LEVEL ' + currentLevel + '!', {
		size: 120,
		fill: 0xFFFFFF
	});
	levelUpText.anchor.set(0.5, 0.5);
	game.addChild(levelUpText);
	levelUpText.x = 2048 / 2;
	levelUpText.y = 2732 / 2;
	// Flash the screen with enhanced effect
	LK.effects.flashScreen(0xffff00, 1000);
	// Add particle effect for level up
	// Placeholder for particle effect, replace with a valid function if available
	console.log("Particle effect at", 2048 / 2, 2732 / 2, "with color", 0xffff00);
	// Remove level up text after a delay
	LK.setTimeout(function () {
		levelUpText.destroy();
	}, 2000);
	// Update difficulty
	setupLevelDifficulty();
}
// Spawn a new balloon
function spawnBalloon() {
	if (gameOver || gamePaused) {
		return;
	}
	// Determine balloon type based on level and randomness
	var balloonType;
	var balloonValue;
	var balloonSpeed;
	// Random value between 0 and 1
	var rand = Math.random();
	// Increase chance of power-ups and bad balloons as level increases
	var powerupChance = 0.05 + currentLevel * 0.02; // 5% base plus 2% per level
	var badBalloonChance = 0.1 + currentLevel * 0.05; // 10% base plus 5% per level
	if (rand < powerupChance) {
		// Spawn a power-up balloon
		var powerupRand = Math.random();
		if (powerupRand < 0.33) {
			balloonType = 'slow';
		} else if (powerupRand < 0.66) {
			balloonType = 'double';
		} else {
			balloonType = 'freeze';
		}
		balloonValue = 0;
		balloonSpeed = 2 + currentLevel * 0.5;
	} else if (rand < powerupChance + badBalloonChance) {
		// Spawn a bad balloon or bomb
		if (Math.random() < 0.5) {
			balloonType = Math.random() < 0.5 ? 'yellow' : 'purple';
			balloonValue = 10 + currentLevel * 5;
		} else {
			balloonType = 'bomb';
			balloonValue = -20; // Bomb decreases score
		}
		balloonSpeed = 3 + currentLevel * 0.7;
	} else {
		// Spawn a good balloon
		var goodRand = Math.random();
		if (goodRand < 0.33) {
			balloonType = 'red';
		} else if (goodRand < 0.66) {
			balloonType = 'green';
		} else {
			balloonType = 'blue';
		}
		balloonValue = 10 + currentLevel * 3;
		balloonSpeed = 2 + currentLevel * 0.6;
	}
	// Create the balloon
	var balloon = new Balloon(balloonType, balloonSpeed, balloonValue);
	// Position balloon randomly along the bottom of the screen
	balloon.x = Math.random() * (2048 - 200) + 100; // Keep away from edges
	balloon.y = 2732 + 100; // Start below screen
	// Add to game and tracking array
	game.addChild(balloon);
	balloons.push(balloon);
}
// Check for game over conditions
function checkGameOver() {
	// In this simple version, the game doesn't end until the player chooses to end it
	// You could add lives or a timer if desired
}
// Update game state
game.update = function () {
	// Update all balloons
	for (var i = balloons.length - 1; i >= 0; i--) {
		if (balloons[i]) {
			balloons[i].update();
		}
	}
	// Update powerup indicators
	for (var type in powerupIndicators) {
		if (powerupIndicators[type]) {
			powerupIndicators[type].update();
		}
	}
	// Update powerup indicators based on current state
	if (gameSpeed < 1) {
		powerupIndicators['slow'].activate(5000);
	}
	if (pointMultiplier > 1) {
		powerupIndicators['double'].activate(5000);
	}
	if (freezeMode) {
		powerupIndicators['freeze'].activate(3000);
	}
	// Check for game over conditions
	checkGameOver();
};
// Game press event handler
game.down = function (x, y, obj) {
	// This is handled by individual balloon objects
};
// Initialize game on startup
initGame();