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

/**** 
* Classes
****/ 
var Flower = Container.expand(function (type) {
	var self = Container.call(this);
	self.flowerType = type;
	self.gridX = 0;
	self.gridY = 0;
	self.destroyed = false;
	var flowerGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add subtle glow effect
	flowerGraphics.alpha = 0.9;
	self.down = function (x, y, obj) {
		if (!isSwapping && !isMatching) {
			game.selectFlower(self);
		}
	};
	self.animateMatch = function (callback) {
		if (self.isAnimating) {
			if (callback) callback();
			return;
		}
		if (!flowerGraphics || !self.parent || self.destroyed) {
			if (callback) callback();
			return;
		}
		self.isAnimating = true;
		var particlesCompleted = 0;
		var totalParticles = Math.min(3, LK.getScore() > 5000 ? 2 : 3); // Reduce particles at high scores
		var flowerAnimationDone = false;
		var callbackCalled = false;
		function checkAllComplete() {
			if (particlesCompleted >= totalParticles && flowerAnimationDone && callback && !callbackCalled) {
				callbackCalled = true;
				self.isAnimating = false;
				// Use timeout to prevent stack overflow during heavy explosions
				LK.setTimeout(function () {
					try {
						callback();
					} catch (e) {
						console.log('Animation callback error:', e);
					}
				}, 16); // Faster callback timing
			}
		}
		// Create optimized particle explosion effect with performance scaling
		for (var i = 0; i < totalParticles; i++) {
			try {
				var particle = self.attachAsset('particle', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 0.8 + Math.random() * 0.3,
					scaleY: 0.8 + Math.random() * 0.3,
					alpha: 0.8
				});
				var angle = i / totalParticles * Math.PI * 2 + Math.random() * 0.2;
				var distance = 60 + Math.random() * 40; // Reduced distance for performance
				var targetX = Math.cos(angle) * distance;
				var targetY = Math.sin(angle) * distance;
				// Simplified initial motion
				particle.x = Math.cos(angle) * 8;
				particle.y = Math.sin(angle) * 8;
				tween(particle, {
					x: targetX,
					y: targetY,
					scaleX: 0.1,
					scaleY: 0.1,
					alpha: 0,
					rotation: Math.random() * Math.PI
				}, {
					duration: LK.getScore() > 5000 ? 250 : 300,
					// Faster animations at high scores
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (particle && particle.destroy) {
							particle.destroy();
						}
						particlesCompleted++;
						checkAllComplete();
					}
				});
			} catch (e) {
				particlesCompleted++;
				checkAllComplete();
			}
		}
		// Add flower scaling and fade animation with optimized timing
		try {
			// Stop any existing tweens
			tween.stop(flowerGraphics);
			tween(flowerGraphics, {
				scaleX: 1.2,
				scaleY: 1.2,
				alpha: 0,
				rotation: Math.random() * Math.PI * 0.1
			}, {
				duration: LK.getScore() > 5000 ? 200 : 250,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					self.visible = false;
					flowerAnimationDone = true;
					checkAllComplete();
				}
			});
		} catch (e) {
			self.visible = false;
			flowerAnimationDone = true;
			checkAllComplete();
		}
	};
	self.animateFall = function (targetY, callback) {
		// Prevent multiple fall animations on same flower
		if (self.isFalling || self.destroyed || !self.parent) {
			if (callback) {
				LK.setTimeout(callback, 8); // Faster callback for performance
			}
			return;
		}
		self.isFalling = true;
		// Calculate fall distance for dynamic duration with performance scaling
		var fallDistance = Math.abs(targetY - self.y);
		var baseDuration = LK.getScore() > 8000 ? 80 : LK.getScore() > 5000 ? 100 : 120;
		var dynamicDuration = Math.min(baseDuration + fallDistance / 600 * 40, LK.getScore() > 5000 ? 200 : 300);
		// Stop all existing tweens to prevent conflicts
		tween.stop(self);
		// Ensure flower is in proper state
		self.scaleX = 1.0;
		self.scaleY = 1.0;
		self.rotation = 0;
		// Optimized fall animation with performance-based easing
		tween(self, {
			y: targetY
		}, {
			duration: dynamicDuration,
			easing: LK.getScore() > 5000 ? tween.linear : tween.easeOut,
			onFinish: function onFinish() {
				self.isFalling = false;
				if (callback) {
					// Use faster setTimeout to prevent stack overflow while maintaining performance
					LK.setTimeout(function () {
						try {
							callback();
						} catch (e) {
							console.log('Fall callback error:', e);
						}
					}, 8);
				}
			}
		});
	};
	// Override destroy to set destroyed flag
	var originalDestroy = self.destroy;
	self.destroy = function () {
		self.destroyed = true;
		self.isFalling = false;
		self.isAnimating = false;
		tween.stop(self);
		if (originalDestroy) originalDestroy.call(self);
	};
	return self;
});
var ShimmerFlower = Flower.expand(function (type) {
	var self = Flower.call(this, type);
	self.isShimmer = true;
	// Add shimmer particles around the flower
	self.shimmerParticles = [];
	for (var i = 0; i < 6; i++) {
		var shimmer = self.attachAsset('shimmerEffect', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.8
		});
		self.shimmerParticles.push(shimmer);
	}
	// Animate shimmer effect continuously
	self.animateShimmer = function () {
		for (var i = 0; i < self.shimmerParticles.length; i++) {
			var particle = self.shimmerParticles[i];
			var angle = i / self.shimmerParticles.length * Math.PI * 2;
			var radius = 55 + Math.sin(LK.ticks * 0.05 + i) * 8;
			particle.x = Math.cos(angle + LK.ticks * 0.04) * radius;
			particle.y = Math.sin(angle + LK.ticks * 0.04) * radius;
			particle.alpha = 0.7 + Math.sin(LK.ticks * 0.08 + i) * 0.2;
			particle.scaleX = 0.9 + Math.sin(LK.ticks * 0.06 + i) * 0.15;
			particle.scaleY = 0.9 + Math.sin(LK.ticks * 0.06 + i) * 0.15;
		}
	};
	self.update = function () {
		self.animateShimmer();
	};
	self.activateShimmerEffect = function () {
		if (!grid || !grid.flowers || !self.parent) return;
		// Shimmer Effect: Explodes in a cross pattern (self + adjacent flowers)
		try {
			var onExplosionComplete = function onExplosionComplete() {
				explosionsCompleted++;
				if (explosionsCompleted >= totalExplosions) {
					var newScore = LK.getScore() + flowersToExplode.length * 25;
					LK.setScore(newScore);
					if (scoreTxt && scoreTxt.setText) scoreTxt.setText('Score: ' + newScore);
					// Optimized high score update with error handling
					if (game && game.updateHighScore) game.updateHighScore(newScore);
					LK.setTimeout(function () {
						if (grid && grid.dropFlowers) {
							grid.dropFlowers(function () {
								if (game && game.checkForMatches) game.checkForMatches();
							});
						}
					}, 200);
				}
			}; // Explode all flowers in the list
			// Create special shimmer explosion effect on self first
			self.createShimmerExplosion();
			var flowersToExplode = [];
			// Add self to explosion list
			flowersToExplode.push({
				x: self.gridX,
				y: self.gridY
			});
			// Add adjacent flowers (up, down, left, right)
			var adjacentPositions = [{
				x: self.gridX,
				y: self.gridY - 1
			},
			// up
			{
				x: self.gridX,
				y: self.gridY + 1
			},
			// down
			{
				x: self.gridX - 1,
				y: self.gridY
			},
			// left
			{
				x: self.gridX + 1,
				y: self.gridY
			} // right
			];
			for (var i = 0; i < adjacentPositions.length; i++) {
				var pos = adjacentPositions[i];
				if (pos.x >= 0 && pos.x < grid.gridSize && pos.y >= 0 && pos.y < grid.gridSize && grid.flowers[pos.y] && grid.flowers[pos.y][pos.x] && grid.flowers[pos.y][pos.x] !== self) {
					flowersToExplode.push(pos);
				}
			}
			// Explode all flowers in the list with smooth timing
			var explosionsCompleted = 0;
			var totalExplosions = flowersToExplode.length;
			for (var i = 0; i < flowersToExplode.length; i++) {
				var pos = flowersToExplode[i];
				if (pos.y >= 0 && pos.y < grid.gridSize && pos.x >= 0 && pos.x < grid.gridSize && grid.flowers[pos.y] && grid.flowers[pos.y][pos.x]) {
					var flower = grid.flowers[pos.y][pos.x];
					if (flower && flower.animateMatch) {
						flower.animateMatch(onExplosionComplete);
						grid.flowers[pos.y][pos.x] = null;
					} else {
						onExplosionComplete();
					}
				} else {
					onExplosionComplete();
				}
			}
		} catch (e) {
			console.log('Shimmer effect error:', e);
		}
	};
	self.createShimmerExplosion = function () {
		// Create optimized shimmer explosion with performance scaling
		try {
			// Reduce particle count based on score for performance
			var particleCount = LK.getScore() > 8000 ? 4 : LK.getScore() > 5000 ? 6 : 8;
			// Create shimmer burst effect
			for (var i = 0; i < particleCount; i++) {
				var shimmerParticle = self.attachAsset('shimmerEffect', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 1.0 + Math.random() * 0.4,
					scaleY: 1.0 + Math.random() * 0.4,
					alpha: 0.9
				});
				var angle = i / particleCount * Math.PI * 2;
				var distance = 100 + Math.random() * 50;
				var targetX = Math.cos(angle) * distance;
				var targetY = Math.sin(angle) * distance;
				tween(shimmerParticle, {
					x: targetX,
					y: targetY,
					scaleX: 0.05,
					scaleY: 0.05,
					alpha: 0,
					rotation: Math.random() * Math.PI * 2
				}, {
					duration: LK.getScore() > 5000 ? 300 : 400,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (shimmerParticle && shimmerParticle.destroy) shimmerParticle.destroy();
					}
				});
			}
		} catch (e) {
			console.log('Shimmer explosion creation error:', e);
		}
	};
	self.explode = function () {
		// Create optimized explosion effect
		try {
			for (var i = 0; i < 12; i++) {
				var particle = self.attachAsset('particle', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 1.5 + Math.random() * 1.0,
					scaleY: 1.5 + Math.random() * 1.0,
					alpha: 1.0
				});
				var angle = i / 12 * Math.PI * 2 + Math.random() * 0.5;
				var distance = 150 + Math.random() * 100;
				var targetX = Math.cos(angle) * distance;
				var targetY = Math.sin(angle) * distance;
				tween(particle, {
					x: targetX,
					y: targetY,
					scaleX: 0.1,
					scaleY: 0.1,
					alpha: 0,
					rotation: Math.random() * Math.PI * 6
				}, {
					duration: 600 + Math.random() * 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (particle && particle.destroy) particle.destroy();
					}
				});
			}
		} catch (e) {
			console.log('Shimmer explosion error:', e);
		}
	};
	return self;
});
var RainbowFlower = Flower.expand(function (type) {
	var self = Flower.call(this, type);
	self.isRainbow = true;
	// Add rainbow particles around the flower
	self.rainbowParticles = [];
	for (var i = 0; i < 6; i++) {
		var rainbow = self.attachAsset('rainbowEffect', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.7
		});
		self.rainbowParticles.push(rainbow);
	}
	// Animate rainbow effect continuously
	self.animateRainbow = function () {
		for (var i = 0; i < self.rainbowParticles.length; i++) {
			var particle = self.rainbowParticles[i];
			var angle = i / self.rainbowParticles.length * Math.PI * 2;
			var radius = 70 + Math.sin(LK.ticks * 0.04 + i * 0.3) * 12;
			particle.x = Math.cos(angle + LK.ticks * 0.03) * radius;
			particle.y = Math.sin(angle + LK.ticks * 0.03) * radius;
			particle.scaleX = 0.95 + Math.sin(LK.ticks * 0.05 + i * 0.4) * 0.15;
			particle.scaleY = 0.95 + Math.sin(LK.ticks * 0.05 + i * 0.4) * 0.15;
			particle.alpha = 0.75 + Math.sin(LK.ticks * 0.06 + i) * 0.15;
		}
	};
	self.update = function () {
		self.animateRainbow();
	};
	self.activateRainbowEffect = function (targetType) {
		if (!grid || !grid.flowers || !targetType || !self.parent) return;
		// Rainbow Effect: Clears all flowers of the target type across the entire board
		try {
			// Create special rainbow explosion effect on self first
			self.createRainbowExplosion();
			// Activate rainbow power-up on target flower type
			var clearedCount = self.explodeAndClear(targetType);
			// Remove self from grid
			self.visible = false;
			if (grid.flowers[self.gridY] && grid.flowers[self.gridY][self.gridX]) {
				grid.flowers[self.gridY][self.gridX] = null;
			}
			var newScore = LK.getScore() + clearedCount * 30;
			LK.setScore(newScore);
			if (scoreTxt && scoreTxt.setText) scoreTxt.setText('Score: ' + newScore);
			// Optimized high score update with error handling
			if (game && game.updateHighScore) game.updateHighScore(newScore);
			LK.setTimeout(function () {
				if (grid && grid.dropFlowers) {
					grid.dropFlowers(function () {
						if (game && game.checkForMatches) game.checkForMatches();
					});
				}
			}, 300);
		} catch (e) {
			console.log('Rainbow effect error:', e);
		}
	};
	self.createRainbowExplosion = function () {
		// Create optimized rainbow explosion with performance scaling
		try {
			// Scale particle count based on performance needs
			var particleCount = LK.getScore() > 8000 ? 8 : LK.getScore() > 5000 ? 12 : 16;
			var animationDuration = LK.getScore() > 5000 ? 400 : 600;
			// Create rainbow wave effect
			for (var i = 0; i < particleCount; i++) {
				var rainbowParticle = self.attachAsset('rainbowEffect', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 0.9 + Math.random() * 0.3,
					scaleY: 0.9 + Math.random() * 0.3,
					alpha: 0.8
				});
				var angle = i / particleCount * Math.PI * 2;
				var distance = 150 + Math.random() * 80;
				var targetX = Math.cos(angle) * distance;
				var targetY = Math.sin(angle) * distance;
				// Reduced stagger timing for faster performance
				var staggerDelay = LK.getScore() > 5000 ? i * 15 : i * 25;
				LK.setTimeout(function (particle, tx, ty) {
					return function () {
						tween(particle, {
							x: tx,
							y: ty,
							scaleX: 0.05,
							scaleY: 0.05,
							alpha: 0,
							rotation: Math.random() * Math.PI * 2
						}, {
							duration: animationDuration,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								if (particle && particle.destroy) particle.destroy();
							}
						});
					};
				}(rainbowParticle, targetX, targetY), staggerDelay);
			}
		} catch (e) {
			console.log('Rainbow explosion creation error:', e);
		}
	};
	self.explodeAndClear = function (targetType) {
		// Find all flowers of target type and clear them
		var clearedFlowers = [];
		try {
			for (var y = 0; y < grid.gridSize; y++) {
				for (var x = 0; x < grid.gridSize; x++) {
					var flower = grid.flowers[y][x];
					if (flower && flower.flowerType === targetType && !flower.isShimmer && !flower.isRainbow && flower !== self) {
						clearedFlowers.push({
							x: x,
							y: y
						});
					}
				}
			}
			// Animate explosion for each cleared flower with staggered timing
			for (var i = 0; i < clearedFlowers.length; i++) {
				var pos = clearedFlowers[i];
				// Validate array bounds and flower existence
				if (pos.y >= 0 && pos.y < grid.gridSize && pos.x >= 0 && pos.x < grid.gridSize && grid.flowers[pos.y] && grid.flowers[pos.y][pos.x]) {
					var flower = grid.flowers[pos.y][pos.x];
					// Stagger the explosions for visual effect
					(function (f, delay) {
						LK.setTimeout(function () {
							if (f && f.animateMatch) f.animateMatch();
						}, delay);
					})(flower, i * 50);
					grid.flowers[pos.y][pos.x] = null;
				}
			}
		} catch (e) {
			console.log('Rainbow clear error:', e);
		}
		return clearedFlowers.length;
	};
	return self;
});
var Grid = Container.expand(function () {
	var self = Container.call(this);
	self.gridSize = 8;
	self.cellSize = 200;
	self.flowers = [];
	self.flowerTypes = ['rose', 'tulip', 'daisy', 'sunflower', 'lily'];
	// Initialize 2D array
	for (var i = 0; i < self.gridSize; i++) {
		self.flowers[i] = [];
		for (var j = 0; j < self.gridSize; j++) {
			self.flowers[i][j] = null;
		}
	}
	self.createFlower = function (gridX, gridY, flowerType, special) {
		// Validate input parameters
		if (gridX < 0 || gridX >= self.gridSize || gridY < 0 || gridY >= self.gridSize) {
			return null;
		}
		if (!self.flowers[gridY]) {
			self.flowers[gridY] = [];
		}
		var type = flowerType || self.flowerTypes[Math.floor(Math.random() * self.flowerTypes.length)];
		var flower;
		try {
			if (special === 'shimmer') {
				flower = new ShimmerFlower(type);
			} else if (special === 'rainbow') {
				flower = new RainbowFlower(type);
			} else {
				flower = new Flower(type);
			}
			if (!flower) return null;
			flower.gridX = gridX;
			flower.gridY = gridY;
			flower.x = gridX * self.cellSize + self.cellSize / 2;
			flower.y = gridY * self.cellSize + self.cellSize / 2;
			self.flowers[gridY][gridX] = flower;
			self.addChild(flower);
			return flower;
		} catch (e) {
			console.log('Error creating flower:', e);
			return null;
		}
	};
	self.initializeGrid = function () {
		// Initialize 2D array properly
		for (var y = 0; y < self.gridSize; y++) {
			if (!self.flowers[y]) self.flowers[y] = [];
			for (var x = 0; x < self.gridSize; x++) {
				try {
					self.createFlower(x, y);
				} catch (e) {
					console.log('Error creating flower at', x, y, e);
				}
			}
		}
	};
	self.swapFlowers = function (flower1, flower2, callback) {
		if (!flower1 || !flower2 || flower1.destroyed || flower2.destroyed) {
			if (callback) callback();
			return;
		}
		var tempX = flower1.gridX;
		var tempY = flower1.gridY;
		// Update grid positions
		flower1.gridX = flower2.gridX;
		flower1.gridY = flower2.gridY;
		flower2.gridX = tempX;
		flower2.gridY = tempY;
		// Update array
		self.flowers[flower1.gridY][flower1.gridX] = flower1;
		self.flowers[flower2.gridY][flower2.gridX] = flower2;
		// Animate swap with smooth, consistent movement
		var targetX1 = flower1.gridX * self.cellSize + self.cellSize / 2;
		var targetY1 = flower1.gridY * self.cellSize + self.cellSize / 2;
		var targetX2 = flower2.gridX * self.cellSize + self.cellSize / 2;
		var targetY2 = flower2.gridY * self.cellSize + self.cellSize / 2;
		var completed = 0;
		function onComplete() {
			completed++;
			if (completed === 2 && callback) {
				callback();
			}
		}
		// Stop any existing tweens on flowers to prevent conflicts
		tween.stop(flower1);
		tween.stop(flower2);
		// Ensure flowers are in proper state
		flower1.scaleX = 1.0;
		flower1.scaleY = 1.0;
		flower1.rotation = 0;
		flower2.scaleX = 1.0;
		flower2.scaleY = 1.0;
		flower2.rotation = 0;
		// Create smooth arc motion effect
		var midX1 = (flower1.x + targetX1) / 2;
		var midY1 = (flower1.y + targetY1) / 2 - 30;
		var midX2 = (flower2.x + targetX2) / 2;
		var midY2 = (flower2.y + targetY2) / 2 - 30;
		// First phase - move to mid point with slight scale effect
		tween(flower1, {
			x: midX1,
			y: midY1,
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 125,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Second phase - complete the swap
				tween(flower1, {
					x: targetX1,
					y: targetY1,
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 125,
					easing: tween.easeIn,
					onFinish: onComplete
				});
			}
		});
		tween(flower2, {
			x: midX2,
			y: midY2,
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 125,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Second phase - complete the swap
				tween(flower2, {
					x: targetX2,
					y: targetY2,
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 125,
					easing: tween.easeIn,
					onFinish: onComplete
				});
			}
		});
	};
	self.findMatches = function () {
		var matches = [];
		var matchGroups = [];
		// Check horizontal matches
		for (var y = 0; y < self.gridSize; y++) {
			if (!self.flowers[y]) continue;
			var count = 1;
			var currentType = self.flowers[y][0] ? self.flowers[y][0].flowerType : null;
			for (var x = 1; x < self.gridSize; x++) {
				var flower = self.flowers[y][x] || null;
				if (flower && flower.flowerType === currentType) {
					count++;
				} else {
					if (count >= 3 && currentType) {
						var group = {
							type: currentType,
							count: count,
							positions: []
						};
						for (var i = x - count; i < x; i++) {
							var pos = {
								x: i,
								y: y
							};
							matches.push(pos);
							group.positions.push(pos);
						}
						matchGroups.push(group);
					}
					count = 1;
					currentType = flower ? flower.flowerType : null;
				}
			}
			if (count >= 3 && currentType) {
				var group = {
					type: currentType,
					count: count,
					positions: []
				};
				for (var i = self.gridSize - count; i < self.gridSize; i++) {
					var pos = {
						x: i,
						y: y
					};
					matches.push(pos);
					group.positions.push(pos);
				}
				matchGroups.push(group);
			}
		}
		// Check vertical matches
		for (var x = 0; x < self.gridSize; x++) {
			var count = 1;
			var currentType = self.flowers[0] && self.flowers[0][x] ? self.flowers[0][x].flowerType : null;
			for (var y = 1; y < self.gridSize; y++) {
				if (!self.flowers[y]) continue;
				var flower = self.flowers[y][x] || null;
				if (flower && flower.flowerType === currentType) {
					count++;
				} else {
					if (count >= 3 && currentType) {
						var group = {
							type: currentType,
							count: count,
							positions: []
						};
						for (var i = y - count; i < y; i++) {
							var pos = {
								x: x,
								y: i
							};
							matches.push(pos);
							group.positions.push(pos);
						}
						matchGroups.push(group);
					}
					count = 1;
					currentType = flower ? flower.flowerType : null;
				}
			}
			if (count >= 3 && currentType) {
				var group = {
					type: currentType,
					count: count,
					positions: []
				};
				for (var i = self.gridSize - count; i < self.gridSize; i++) {
					var pos = {
						x: x,
						y: i
					};
					matches.push(pos);
					group.positions.push(pos);
				}
				matchGroups.push(group);
			}
		}
		return {
			matches: matches,
			groups: matchGroups
		};
	};
	self.removeMatches = function (matchResult, callback) {
		if (!matchResult || matchResult.matches.length === 0) {
			if (callback) callback();
			return;
		}
		var matches = matchResult.matches;
		var groups = matchResult.groups || [];
		var powerUpsCreated = [];
		var animationsCompleted = 0;
		var totalAnimations = 0;
		var callbackExecuted = false;
		// Check for power-up creation opportunities
		try {
			for (var g = 0; g < groups.length; g++) {
				var group = groups[g];
				if (group && group.count >= 5 && group.positions && group.positions.length > 0) {
					// Create rainbow flower at center position
					var centerPos = group.positions[Math.floor(group.positions.length / 2)];
					powerUpsCreated.push({
						pos: centerPos,
						type: group.type,
						special: 'rainbow'
					});
				} else if (group && group.count >= 4 && group.positions && group.positions.length > 0) {
					// Create shimmer flower at center position
					var centerPos = group.positions[Math.floor(group.positions.length / 2)];
					powerUpsCreated.push({
						pos: centerPos,
						type: group.type,
						special: 'shimmer'
					});
				}
			}
		} catch (e) {
			console.log('Power-up creation error:', e);
		}
		function onAnimationComplete() {
			animationsCompleted++;
			if (animationsCompleted === totalAnimations && !callbackExecuted) {
				callbackExecuted = true;
				// Create power-up flowers after all match animations complete
				try {
					for (var p = 0; p < powerUpsCreated.length; p++) {
						var powerUp = powerUpsCreated[p];
						// Validate position is within bounds and empty
						if (powerUp && powerUp.pos && powerUp.pos.y >= 0 && powerUp.pos.y < self.gridSize && powerUp.pos.x >= 0 && powerUp.pos.x < self.gridSize && self.flowers[powerUp.pos.y] && !self.flowers[powerUp.pos.y][powerUp.pos.x]) {
							var newPowerUpFlower = self.createFlower(powerUp.pos.x, powerUp.pos.y, powerUp.type, powerUp.special);
							// Add visual feedback for power-up creation
							newPowerUpFlower.scaleX = 0.3;
							newPowerUpFlower.scaleY = 0.3;
							newPowerUpFlower.alpha = 0.8;
							tween(newPowerUpFlower, {
								scaleX: 1.1,
								scaleY: 1.1,
								alpha: 1.0
							}, {
								duration: 200,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									tween(newPowerUpFlower, {
										scaleX: 1.0,
										scaleY: 1.0
									}, {
										duration: 100,
										easing: tween.easeOut
									});
								}
							});
						}
					}
				} catch (e) {
					console.log('Power-up placement error:', e);
				}
				// Execute callback with timeout to prevent stack overflow
				LK.setTimeout(function () {
					if (callback) callback();
				}, 16);
			}
		}
		// Process matches and start animations
		for (var i = 0; i < matches.length; i++) {
			var match = matches[i];
			if (match && match.y >= 0 && match.y < self.gridSize && match.x >= 0 && match.x < self.gridSize && self.flowers[match.y] && self.flowers[match.y][match.x]) {
				var flower = self.flowers[match.y][match.x];
				if (flower && flower.animateMatch) {
					self.flowers[match.y][match.x] = null; // Clear immediately
					totalAnimations++;
					flower.animateMatch(onAnimationComplete);
				}
			}
		}
		// Handle case where no animations are needed
		if (totalAnimations === 0) {
			// Create power-ups immediately if no animations
			try {
				for (var p = 0; p < powerUpsCreated.length; p++) {
					var powerUp = powerUpsCreated[p];
					if (powerUp && powerUp.pos && powerUp.pos.y >= 0 && powerUp.pos.y < self.gridSize && powerUp.pos.x >= 0 && powerUp.pos.x < self.gridSize && self.flowers[powerUp.pos.y] && !self.flowers[powerUp.pos.y][powerUp.pos.x]) {
						var newPowerUpFlower = self.createFlower(powerUp.pos.x, powerUp.pos.y, powerUp.type, powerUp.special);
						newPowerUpFlower.scaleX = 0.2;
						newPowerUpFlower.scaleY = 0.2;
						tween(newPowerUpFlower, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 300,
							easing: tween.easeOut
						});
					}
				}
			} catch (e) {
				console.log('Immediate power-up creation error:', e);
			}
			if (callback) callback();
		}
	};
	self.dropFlowers = function (callback) {
		var animations = 0;
		var animationCompleted = false;
		var timeoutId = null;
		function onAnimationComplete() {
			animations--;
			if (animations === 0 && !animationCompleted && callback) {
				animationCompleted = true;
				if (timeoutId) LK.clearTimeout(timeoutId);
				callback();
			}
		}
		// Safety timeout to prevent infinite waiting
		timeoutId = LK.setTimeout(function () {
			if (!animationCompleted && callback) {
				animationCompleted = true;
				callback();
			}
		}, 5000);
		// Process each column independently
		for (var x = 0; x < self.gridSize; x++) {
			// Ensure column exists
			if (!self.flowers) self.flowers = [];
			for (var y = 0; y < self.gridSize; y++) {
				if (!self.flowers[y]) self.flowers[y] = [];
			}
			// Collect existing flowers in this column (bottom to top)
			var existingFlowers = [];
			for (var y = self.gridSize - 1; y >= 0; y--) {
				if (self.flowers[y][x]) {
					existingFlowers.push(self.flowers[y][x]);
					self.flowers[y][x] = null; // Clear the position
				}
			}
			// Place existing flowers at bottom positions
			var currentPos = self.gridSize - 1;
			for (var i = 0; i < existingFlowers.length; i++) {
				var flower = existingFlowers[i];
				if (flower && currentPos >= 0) {
					self.flowers[currentPos][x] = flower;
					flower.gridX = x;
					flower.gridY = currentPos;
					// Animate fall if needed
					var targetY = currentPos * self.cellSize + self.cellSize / 2;
					if (Math.abs(flower.y - targetY) > 10) {
						animations++;
						(function (f, ty) {
							// Stop any existing fall animations
							tween.stop(f);
							f.isFalling = false;
							f.animateFall(ty, onAnimationComplete);
						})(flower, targetY);
					} else {
						flower.y = targetY; // Snap to position if very close
					}
					currentPos--;
				}
			}
			// Create new flowers for remaining empty spaces
			for (var y = 0; y <= currentPos; y++) {
				var newFlower = self.createFlower(x, y);
				if (newFlower) {
					newFlower.y = -self.cellSize - (currentPos - y) * 50; // Stagger starting positions
					var targetY = y * self.cellSize + self.cellSize / 2;
					animations++;
					(function (f, ty) {
						f.animateFall(ty, onAnimationComplete);
					})(newFlower, targetY);
				}
			}
		}
		// Handle case where no animations are needed
		if (animations === 0 && callback) {
			callback();
		}
	};
	self.isAdjacent = function (flower1, flower2) {
		var dx = Math.abs(flower1.gridX - flower2.gridX);
		var dy = Math.abs(flower1.gridY - flower2.gridY);
		return dx === 1 && dy === 0 || dx === 0 && dy === 1;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create beautiful flower garden background
var gardenBg = game.attachAsset('gardenBackground', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
var grid = new Grid();
var selectedFlower = null;
var isSwapping = false;
var isMatching = false;
// Position grid in center of screen
grid.x = (2048 - grid.gridSize * grid.cellSize) / 2;
grid.y = (2732 - grid.gridSize * grid.cellSize) / 2 + 200;
game.addChild(grid);
// Score display
var scoreTxt = new Text2('Score: 0', {
	size: 120,
	fill: 0x2D5016
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// High score display
var highScoreTxt = new Text2('High Score: 0', {
	size: 80,
	fill: 0x1a3d0b
});
highScoreTxt.anchor.set(0.5, 0);
highScoreTxt.y = 140;
LK.gui.top.addChild(highScoreTxt);
// Initialize high score from storage with error handling
var highScore = 0;
try {
	if (storage && typeof storage.highScore === 'number') {
		highScore = storage.highScore;
	} else {
		highScore = 0;
	}
} catch (e) {
	console.log('Storage read error, using default high score');
	highScore = 0;
}
try {
	if (highScoreTxt && highScoreTxt.setText) {
		highScoreTxt.setText('High Score: ' + highScore);
	}
} catch (e) {
	console.log('High score display initialization error:', e);
}
// Centralized high score update system with debouncing
var highScoreUpdateTimer = null;
var pendingHighScoreUpdate = false;
var lastHighScoreUpdate = 0;
game.updateHighScore = function (newScore) {
	if (!newScore || typeof newScore !== 'number') return;
	var currentTime = Date.now();
	var updateDelay = LK.getScore() > 8000 ? 2000 : LK.getScore() > 5000 ? 1500 : 500;
	if (newScore > highScore && !pendingHighScoreUpdate && currentTime - lastHighScoreUpdate > updateDelay) {
		lastHighScoreUpdate = currentTime;
		highScore = newScore;
		try {
			if (highScoreTxt && highScoreTxt.setText) {
				highScoreTxt.setText('High Score: ' + highScore);
			}
		} catch (e) {
			console.log('High score display error:', e);
		}
		pendingHighScoreUpdate = true;
		// Increased debounce time for high scores to prevent performance issues
		if (highScoreUpdateTimer) {
			LK.clearTimeout(highScoreUpdateTimer);
		}
		var storageDelay = LK.getScore() > 8000 ? 3000 : LK.getScore() > 5000 ? 2000 : 1000;
		highScoreUpdateTimer = LK.setTimeout(function () {
			try {
				if (storage) {
					storage.highScore = highScore;
				}
			} catch (e) {
				console.log('Storage write error:', e);
			}
			highScoreUpdateTimer = null;
			pendingHighScoreUpdate = false;
		}, storageDelay);
	}
};
// Add performance monitoring variables
var performanceOptimized = false;
var particlePool = [];
var maxPoolSize = 50;
// Performance optimization function
function optimizeForHighScore() {
	if (!performanceOptimized && LK.getScore() > 5000) {
		performanceOptimized = true;
		// Reduce animation complexity for better performance
		maxMatchChecks = 15;
		minSwipeDistance = 40;
		console.log('Performance mode activated for high score gameplay');
	}
}
// Initialize grid with staggered creation to prevent startup lag
var initializationStep = 0;
var totalCells = grid.gridSize * grid.gridSize;
function initializeGridStep() {
	var cellsPerStep = 8; // Create 8 flowers per frame
	var endStep = Math.min(initializationStep + cellsPerStep, totalCells);
	for (var i = initializationStep; i < endStep; i++) {
		var x = i % grid.gridSize;
		var y = Math.floor(i / grid.gridSize);
		try {
			grid.createFlower(x, y);
		} catch (e) {
			console.log('Error creating flower at', x, y, e);
		}
	}
	initializationStep = endStep;
	if (initializationStep < totalCells) {
		LK.setTimeout(initializeGridStep, 16); // Continue next frame
	} else {
		// Grid initialization complete, start game
		LK.setTimeout(function () {
			game.checkForMatches();
		}, 300);
	}
}
// Start staggered initialization
initializeGridStep();
game.selectFlower = function (flower) {
	// Prevent selection during animations
	if (isSwapping || isMatching || !flower || flower.destroyed) {
		return;
	}
	if (selectedFlower === null) {
		// First selection with smooth scale animation
		selectedFlower = flower;
		// Stop any existing tweens to prevent conflicts
		tween.stop(flower);
		// Set initial state for smooth animation
		flower.scaleX = 1.0;
		flower.scaleY = 1.0;
		flower.rotation = 0;
		tween(flower, {
			scaleX: 1.15,
			scaleY: 1.15
		}, {
			duration: 200,
			easing: tween.easeInOut
		});
		// Add smooth pulse effect
		tween(flower, {
			rotation: 0.05
		}, {
			duration: 300,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(flower, {
					rotation: -0.05
				}, {
					duration: 300,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(flower, {
							rotation: 0
						}, {
							duration: 200,
							easing: tween.easeInOut
						});
					}
				});
			}
		});
	} else if (selectedFlower === flower) {
		// Deselect same flower with smooth transition
		tween.stop(flower);
		tween(flower, {
			scaleX: 1,
			scaleY: 1,
			rotation: 0
		}, {
			duration: 250,
			easing: tween.easeInOut
		});
		selectedFlower = null;
	} else if (grid.isAdjacent(selectedFlower, flower)) {
		// Valid swap
		isSwapping = true;
		var firstFlower = selectedFlower;
		// Smooth deselection animation
		tween.stop(firstFlower);
		tween(firstFlower, {
			scaleX: 1,
			scaleY: 1,
			rotation: 0
		}, {
			duration: 200,
			easing: tween.easeInOut
		});
		LK.getSound('swap').play();
		// Check for special flower activation during swap
		if (firstFlower.isShimmer) {
			// Shimmer flower swapped - activate shimmer effect
			selectedFlower = null;
			firstFlower.activateShimmerEffect();
			isSwapping = false;
		} else if (flower.isShimmer) {
			// Target flower is shimmer - activate shimmer effect
			selectedFlower = null;
			flower.activateShimmerEffect();
			isSwapping = false;
		} else if (firstFlower.isRainbow && flower.flowerType && !flower.isRainbow && !flower.isShimmer) {
			// Rainbow flower swapped with regular flower - activate rainbow effect
			selectedFlower = null;
			firstFlower.activateRainbowEffect(flower.flowerType);
			isSwapping = false;
		} else if (flower.isRainbow && firstFlower.flowerType && !firstFlower.isRainbow && !firstFlower.isShimmer) {
			// Target flower is rainbow - activate rainbow effect
			selectedFlower = null;
			flower.activateRainbowEffect(firstFlower.flowerType);
			isSwapping = false;
		} else {
			// Regular swap
			grid.swapFlowers(firstFlower, flower, function () {
				selectedFlower = null;
				isSwapping = false;
				game.checkForMatches();
			});
		}
	} else {
		// Invalid swap - select new flower with smooth transition
		tween.stop(selectedFlower);
		tween(selectedFlower, {
			scaleX: 1,
			scaleY: 1,
			rotation: 0
		}, {
			duration: 250,
			easing: tween.easeInOut
		});
		selectedFlower = flower;
		// Stop any existing tweens on new flower
		tween.stop(flower);
		flower.scaleX = 1.0;
		flower.scaleY = 1.0;
		flower.rotation = 0;
		tween(flower, {
			scaleX: 1.15,
			scaleY: 1.15
		}, {
			duration: 200,
			easing: tween.easeInOut
		});
		// Add smooth pulse effect for new selection
		tween(flower, {
			rotation: 0.05
		}, {
			duration: 300,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(flower, {
					rotation: -0.05
				}, {
					duration: 300,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(flower, {
							rotation: 0
						}, {
							duration: 200,
							easing: tween.easeInOut
						});
					}
				});
			}
		});
	}
};
var matchCheckCount = 0;
var maxMatchChecks = 20;
var lastMatchCheckTime = 0;
var matchCheckInProgress = false;
game.checkForMatches = function () {
	// Prevent multiple simultaneous match checks and infinite loops
	var currentTime = Date.now();
	var minDelay = LK.getScore() > 8000 ? 100 : LK.getScore() > 5000 ? 120 : 150;
	if (isMatching || isSwapping || matchCheckInProgress || matchCheckCount >= maxMatchChecks || currentTime - lastMatchCheckTime < minDelay) {
		return;
	}
	lastMatchCheckTime = currentTime;
	matchCheckCount++;
	matchCheckInProgress = true;
	try {
		var matchResult = grid.findMatches();
		if (matchResult && matchResult.matches && matchResult.matches.length > 0) {
			isMatching = true;
			// Reduce sound frequency at high scores to prevent audio lag
			if (LK.getScore() <= 8000) {
				try {
					LK.getSound('match').play();
				} catch (e) {
					console.log('Sound play error:', e);
				}
			}
			// Update score using LK score system only
			var newScore = LK.getScore() + matchResult.matches.length * 10;
			LK.setScore(newScore);
			if (scoreTxt && scoreTxt.setText) scoreTxt.setText('Score: ' + newScore);
			// Optimized high score update with throttling for high scores
			if (newScore <= 8000 || newScore % 100 === 0) {
				// Only update high score every 100 points at high scores
				try {
					game.updateHighScore(newScore);
				} catch (e) {
					console.log('High score update error:', e);
				}
			}
			grid.removeMatches(matchResult, function () {
				grid.dropFlowers(function () {
					isMatching = false;
					matchCheckInProgress = false;
					// Check for cascading matches with adaptive timing
					var cascadeDelay = LK.getScore() > 8000 ? 250 : LK.getScore() > 5000 ? 300 : 400;
					LK.setTimeout(function () {
						if (matchCheckCount < maxMatchChecks && !isMatching && !isSwapping) {
							game.checkForMatches();
						} else {
							matchCheckCount = 0; // Reset counter
							matchCheckInProgress = false;
						}
					}, cascadeDelay);
				});
			});
		} else {
			// No matches found - ensure matching flag is cleared
			isMatching = false;
			matchCheckInProgress = false;
			matchCheckCount = 0; // Reset counter when no matches
		}
	} catch (e) {
		console.log('Match check error:', e);
		isMatching = false;
		matchCheckInProgress = false;
		matchCheckCount = 0;
	}
};
// Swipe detection variables
var swipeStartFlower = null;
var swipeStartX = 0;
var swipeStartY = 0;
var isSwipeActive = false;
var minSwipeDistance = 50;
// Add swipe detection to game
game.down = function (x, y, obj) {
	if (isSwapping || isMatching) return;
	// Convert screen coordinates to game coordinates safely
	var gamePos;
	try {
		if (obj && obj.parent && obj.parent.toGlobal && obj.position) {
			gamePos = game.toLocal(obj.parent.toGlobal(obj.position));
		} else {
			// Fallback to using direct x,y coordinates
			gamePos = {
				x: x,
				y: y
			};
		}
	} catch (e) {
		// Fallback to using direct x,y coordinates if conversion fails
		gamePos = {
			x: x,
			y: y
		};
	}
	// Find flower at touch position more accurately
	var touchedFlower = null;
	var gridLocalX = gamePos.x - grid.x;
	var gridLocalY = gamePos.y - grid.y;
	// More precise grid coordinate calculation
	var gridX = Math.floor((gridLocalX + grid.cellSize * 0.1) / grid.cellSize);
	var gridY = Math.floor((gridLocalY + grid.cellSize * 0.1) / grid.cellSize);
	// Validate grid bounds and flower existence
	if (gridX >= 0 && gridX < grid.gridSize && gridY >= 0 && gridY < grid.gridSize && grid.flowers[gridY] && grid.flowers[gridY][gridX]) {
		touchedFlower = grid.flowers[gridY][gridX];
	}
	if (touchedFlower) {
		swipeStartFlower = touchedFlower;
		swipeStartX = gamePos.x;
		swipeStartY = gamePos.y;
		isSwipeActive = true;
	}
};
game.up = function (x, y, obj) {
	if (!isSwipeActive || !swipeStartFlower || isSwapping || isMatching) {
		isSwipeActive = false;
		swipeStartFlower = null;
		return;
	}
	// Convert end coordinates to game coordinates safely
	var gameEndPos;
	try {
		if (obj && obj.parent && obj.parent.toGlobal && obj.position) {
			gameEndPos = game.toLocal(obj.parent.toGlobal(obj.position));
		} else {
			// Fallback to using direct x,y coordinates
			gameEndPos = {
				x: x,
				y: y
			};
		}
	} catch (e) {
		// Fallback to using direct x,y coordinates if conversion fails
		gameEndPos = {
			x: x,
			y: y
		};
	}
	var deltaX = gameEndPos.x - swipeStartX;
	var deltaY = gameEndPos.y - swipeStartY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	if (distance >= minSwipeDistance) {
		// Determine swipe direction with better accuracy
		var targetGridX = swipeStartFlower.gridX;
		var targetGridY = swipeStartFlower.gridY;
		if (Math.abs(deltaX) > Math.abs(deltaY)) {
			// Horizontal swipe
			if (deltaX > 0) {
				targetGridX++; // Right
			} else {
				targetGridX--; // Left
			}
		} else {
			// Vertical swipe
			if (deltaY > 0) {
				targetGridY++; // Down
			} else {
				targetGridY--; // Up
			}
		}
		// Check if target position is valid and has a flower
		if (targetGridX >= 0 && targetGridX < grid.gridSize && targetGridY >= 0 && targetGridY < grid.gridSize && grid.flowers[targetGridY] && grid.flowers[targetGridY][targetGridX]) {
			var targetFlower = grid.flowers[targetGridY][targetGridX];
			// Use smooth selection and swap with proper timing
			if (swipeStartFlower && swipeStartFlower.scaleX !== undefined) {
				tween(swipeStartFlower, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 100,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (swipeStartFlower && swipeStartFlower.scaleX !== undefined) {
							tween(swipeStartFlower, {
								scaleX: 1.0,
								scaleY: 1.0
							}, {
								duration: 100,
								easing: tween.easeInOut
							});
						}
						if (swipeStartFlower) {
							game.selectFlower(swipeStartFlower);
							LK.setTimeout(function () {
								if (targetFlower) {
									game.selectFlower(targetFlower);
								}
							}, 50);
						}
					}
				});
			}
		}
	}
	isSwipeActive = false;
	swipeStartFlower = null;
};
// Add move handler for visual feedback during swipe
game.move = function (x, y, obj) {
	if (!isSwipeActive || !swipeStartFlower || isSwapping || isMatching) return;
	// Convert coordinates for consistent tracking safely
	var gameMovePos;
	try {
		if (obj && obj.parent && obj.parent.toGlobal && obj.position) {
			gameMovePos = game.toLocal(obj.parent.toGlobal(obj.position));
		} else {
			// Fallback to using direct x,y coordinates
			gameMovePos = {
				x: x,
				y: y
			};
		}
	} catch (e) {
		// Fallback to using direct x,y coordinates if conversion fails
		gameMovePos = {
			x: x,
			y: y
		};
	}
	var deltaX = gameMovePos.x - swipeStartX;
	var deltaY = gameMovePos.y - swipeStartY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	// Provide visual feedback when swipe distance is sufficient
	if (distance >= minSwipeDistance * 0.7) {
		// Scale up the flower being swiped to indicate readiness
		if (swipeStartFlower && swipeStartFlower.scaleX !== undefined && swipeStartFlower.scaleX <= 1.0) {
			tween.stop(swipeStartFlower);
			tween(swipeStartFlower, {
				scaleX: 1.08,
				scaleY: 1.08
			}, {
				duration: 150,
				easing: tween.easeOut
			});
		}
	} else if (swipeStartFlower && swipeStartFlower.scaleX !== undefined && swipeStartFlower.scaleX > 1.0) {
		// Scale back down if swipe distance is insufficient
		tween.stop(swipeStartFlower);
		tween(swipeStartFlower, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 150,
			easing: tween.easeOut
		});
	}
};
// Initial match check after grid creation
LK.setTimeout(function () {
	game.checkForMatches();
}, 300);
game.update = function () {
	// Game runs automatically through event-driven mechanics
	// Add basic error catching for any update cycle issues
	try {
		// Ensure game state consistency
		if (typeof isMatching === 'undefined') isMatching = false;
		if (typeof isSwapping === 'undefined') isSwapping = false;
		if (typeof matchCheckCount === 'undefined') matchCheckCount = 0;
		// Performance optimization check every 60 frames
		if (LK.ticks % 60 === 0) {
			optimizeForHighScore();
		}
		// Memory management - clean up unused tweens every 300 frames
		if (LK.ticks % 300 === 0 && LK.getScore() > 5000) {
			// Force garbage collection opportunity
			if (particlePool.length > maxPoolSize) {
				particlePool.length = maxPoolSize;
			}
		}
		// Adaptive frame skipping for very high scores to maintain smoothness
		if (LK.getScore() > 10000 && LK.ticks % 2 === 0) {
			return; // Skip every other frame at very high scores
		}
	} catch (e) {
		console.log('Game update error:', e);
	}
};