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

/**** 
* Classes
****/ 
var BlueBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('blueBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var BouncingCircle = Container.expand(function () {
	var self = Container.call(this);
	var circleGraphics = self.attachAsset('bouncingCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Velocity properties
	self.velocityX = 12;
	self.velocityY = 10;
	self.update = function () {
		// Move the circle
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Check collision with blue blocks
		for (var i = blocks.length - 1; i >= 0; i--) {
			var block = blocks[i];
			if (self.intersects(block)) {
				// Play blue block sound
				LK.getSound('sonidodebloqueazul').play();
				// Update blue blocks score
				blueBlocksScore++;
				blueScoreText.setText('Blue: ' + blueBlocksScore);
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// Spawn red block at random position with minimum distance from other blocks
				var newRedBlock = game.addChild(new RedBlock());
				var validPosition = false;
				var attempts = 0;
				while (!validPosition && attempts < 50) {
					newRedBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
					newRedBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
					validPosition = true;
					// Check distance from all existing blue blocks
					for (var b = 0; b < blocks.length; b++) {
						var existingBlock = blocks[b];
						var dx = newRedBlock.x - existingBlock.x;
						var dy = newRedBlock.y - existingBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing red blocks
					for (var r = 0; r < redBlocks.length; r++) {
						var existingRedBlock = redBlocks[r];
						var dx = newRedBlock.x - existingRedBlock.x;
						var dy = newRedBlock.y - existingRedBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					attempts++;
				}
				redBlocks.push(newRedBlock);
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = block.x;
					powerOrb.y = block.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the block
				block.destroy();
				blocks.splice(i, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Check collision with red blocks
		for (var j = redBlocks.length - 1; j >= 0; j--) {
			var redBlock = redBlocks[j];
			if (self.intersects(redBlock)) {
				// Play red block sound
				LK.getSound('sonidodebloquerojo').play();
				// Update red blocks score
				redBlocksScore++;
				redScoreText.setText('Red: ' + redBlocksScore);
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = redBlock.x;
					powerOrb.y = redBlock.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the red block
				redBlock.destroy();
				redBlocks.splice(j, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Bounce off screen edges
		if (self.x <= 25) {
			self.x = 25;
			self.velocityX = -self.velocityX;
		}
		if (self.x >= 2048 - 25) {
			self.x = 2048 - 25;
			self.velocityX = -self.velocityX;
		}
		if (self.y <= 25) {
			self.y = 25;
			self.velocityY = -self.velocityY;
		}
		if (self.y >= 2732 - 25) {
			self.y = 2732 - 25;
			self.velocityY = -self.velocityY;
		}
	};
	return self;
});
var CornerBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlock', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
var CornerBlockRight = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlockRight', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
var CornerBlockTop = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlockTop', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
// Cache paddle constants
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Prevent paddle from going through left wall
		if (self.x < PADDLE_HALF_WIDTH) {
			self.x = PADDLE_HALF_WIDTH;
		}
		// Prevent paddle from going through right wall
		if (self.x > SCREEN_WIDTH - PADDLE_HALF_WIDTH) {
			self.x = SCREEN_WIDTH - PADDLE_HALF_WIDTH;
		}
	};
	return self;
});
var PowerOrb = Container.expand(function () {
	var self = Container.call(this);
	var orbGraphics = self.attachAsset('powerOrb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Fall downward
	self.velocityY = 8;
	self.update = function () {
		self.y += self.velocityY;
		// Remove if goes off screen
		if (self.y > 2800) {
			self.destroy();
			// Remove from powerOrbs array
			for (var i = powerOrbs.length - 1; i >= 0; i--) {
				if (powerOrbs[i] === self) {
					powerOrbs.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var RedBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('redBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Add scattered musical wave symbols across the background
var musicalWaves = [];
for (var i = 0; i < 20; i++) {
	var waveType = 'musicalWave' + (Math.floor(Math.random() * 4) + 1);
	var wave = game.addChild(LK.getAsset(waveType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.3,
		rotation: Math.random() * Math.PI * 2
	}));
	musicalWaves.push(wave);
}
// Add scattered musical notes across the background
var musicalNotes = [];
for (var i = 0; i < 15; i++) {
	var noteType = 'musicalNote' + (Math.floor(Math.random() * 3) + 1);
	var note = game.addChild(LK.getAsset(noteType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.25,
		rotation: Math.random() * Math.PI * 2
	}));
	musicalNotes.push(note);
}
// Add staff lines across the background
var staffLines = [];
for (var i = 0; i < 12; i++) {
	var staffType = 'staffLine' + (Math.floor(Math.random() * 3) + 1);
	var staff = game.addChild(LK.getAsset(staffType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.2,
		rotation: Math.random() * Math.PI * 0.5
	}));
	staffLines.push(staff);
}
// Add treble clefs scattered in the background
var trebleClefs = [];
for (var i = 0; i < 8; i++) {
	var clef = game.addChild(LK.getAsset('trebleClef', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.15,
		rotation: Math.random() * Math.PI * 2
	}));
	trebleClefs.push(clef);
}
// Add scattered background circles
var backgroundCircles = [];
for (var i = 0; i < 40; i++) {
	var circleType = 'backgroundCircle' + (Math.floor(Math.random() * 6) + 1);
	var circle = game.addChild(LK.getAsset(circleType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.1
	}));
	backgroundCircles.push(circle);
}
// Cache paddle constants
var PADDLE_HALF_WIDTH = 150;
var SCREEN_WIDTH = 2048;
var blocks = [];
var redBlocks = [];
var powerOrbs = [];
var blueBlocksScore = 0;
var redBlocksScore = 0;
var paddleCollisions = 0;
// Create score text for blue blocks
var blueScoreText = new Text2('Blue: 0', {
	size: 60,
	fill: 0x0066CC
});
blueScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(blueScoreText);
blueScoreText.x = -200;
blueScoreText.y = 60;
// Create score text for red blocks
var redScoreText = new Text2('Red: 0', {
	size: 60,
	fill: 0xFF0000
});
redScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(redScoreText);
redScoreText.x = 200;
redScoreText.y = 60;
var bouncingCircle = game.addChild(new BouncingCircle());
bouncingCircle.x = 1024;
bouncingCircle.y = 2550; // Position above paddle
bouncingCircle.lastIntersecting = false;
var paddle = game.addChild(new Paddle());
paddle.x = 1024;
paddle.y = 2600;
game.move = function (x, y, obj) {
	paddle.x = x;
};
// Add corner block covering entire left side of screen
var cornerBlock = game.addChild(new CornerBlock());
cornerBlock.x = 10; // Position at left edge
cornerBlock.y = 1366; // Center vertically (half of 2732)
// Add corner block covering entire right side of screen
var cornerBlockRight = game.addChild(new CornerBlockRight());
cornerBlockRight.x = 2038; // Position at right edge
cornerBlockRight.y = 1366; // Center vertically (half of 2732)
// Add corner block covering entire top side of screen
var cornerBlockTop = game.addChild(new CornerBlockTop());
cornerBlockTop.x = 1024; // Center horizontally (half of 2048)
cornerBlockTop.y = 10; // Position at top edge
// Play background music
LK.playMusic('musica');
game.update = function () {
	// Track ball-paddle collision state transitions
	var currentIntersecting = bouncingCircle.intersects(paddle);
	if (!bouncingCircle.lastIntersecting && currentIntersecting) {
		// Collision just started - push ball above paddle and reverse Y velocity
		bouncingCircle.y = paddle.y - 20 - 25;
		bouncingCircle.velocityY = -Math.abs(bouncingCircle.velocityY);
		// Increment paddle collision counter
		paddleCollisions++;
		// Add expansion animation to bouncing circle
		tween(bouncingCircle, {
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(bouncingCircle, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
		// Only spawn blue blocks if paddle collisions are less than 10
		if (paddleCollisions < 10) {
			// Spawn new blue block at random position with minimum distance from other blocks
			var newBlock = game.addChild(new BlueBlock());
			var validPosition = false;
			var attempts = 0;
			while (!validPosition && attempts < 50) {
				newBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
				newBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
				validPosition = true;
				// Check distance from all existing blue blocks
				for (var b = 0; b < blocks.length; b++) {
					var existingBlock = blocks[b];
					var dx = newBlock.x - existingBlock.x;
					var dy = newBlock.y - existingBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				// Check distance from all existing red blocks
				for (var r = 0; r < redBlocks.length; r++) {
					var existingRedBlock = redBlocks[r];
					var dx = newBlock.x - existingRedBlock.x;
					var dy = newBlock.y - existingRedBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				attempts++;
			}
			blocks.push(newBlock);
		}
	}
	bouncingCircle.lastIntersecting = currentIntersecting;
	// Check power orb collisions with paddle
	for (var k = powerOrbs.length - 1; k >= 0; k--) {
		var powerOrb = powerOrbs[k];
		if (powerOrb.intersects(paddle)) {
			// Increase ball speed
			var speedMultiplier = 1.5;
			bouncingCircle.velocityX *= speedMultiplier;
			bouncingCircle.velocityY *= speedMultiplier;
			// Visual feedback - flash ball green
			tween(bouncingCircle, {
				tint: 0x00ff00
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						tint: 0xffffff
					}, {
						duration: 200
					});
				}
			});
			// Remove power orb
			powerOrb.destroy();
			powerOrbs.splice(k, 1);
		}
	}
	// Check if ball hits bottom area (game over zone)
	if (bouncingCircle.y >= 2700) {
		LK.showGameOver();
		return;
	}
};