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

/**** 
* Classes
****/ 
// Ball class
var Ball = Container.expand(function () {
	var self = Container.call(this);
	var ballSprite = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = ballSprite.width / 2;
	self.vx = 0;
	self.vy = 0;
	self.speed = 22; // Initial speed
	self.sticky = false; // If true, ball sticks to paddle
	self.launch = function (angle) {
		// Launch ball at angle (in radians)
		self.vx = Math.cos(angle) * self.speed;
		self.vy = Math.sin(angle) * self.speed;
		self.sticky = false;
	};
	self.update = function () {
		if (!self.sticky) {
			self.x += self.vx;
			self.y += self.vy;
		}
	};
	return self;
});
// Block class
var Block = Container.expand(function () {
	var self = Container.call(this);
	// color: 'red', 'green', 'blue', 'yellow'
	self.color = 'red';
	self.hp = 1;
	self.maxHp = 1;
	self.hpBarBg = null;
	self.hpBar = null;
	self.setColor = function (color) {
		self.color = color;
		if (self.blockSprite) self.removeChild(self.blockSprite);
		var assetId = 'block_' + color;
		self.blockSprite = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Remove old HP bars if any
		if (self.hpBarBg) self.removeChild(self.hpBarBg);
		if (self.hpBar) self.removeChild(self.hpBar);
		// Add HP bar background (gray)
		self.hpBarBg = self.attachAsset('block_red', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: self.blockSprite.width * 0.8,
			height: 14,
			y: -self.blockSprite.height / 2 - 18,
			tint: 0x444444
		});
		// Add HP bar (green)
		self.hpBar = self.attachAsset('block_green', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: self.blockSprite.width * 0.78,
			height: 10,
			y: -self.blockSprite.height / 2 - 18,
			tint: 0x44ff44
		});
		self.hpBarBg.alpha = 0.7;
		self.hpBar.alpha = 0.9;
		self.hpBarBg.zIndex = 10;
		self.hpBar.zIndex = 11;
		self.hpBarBg.interactive = false;
		self.hpBar.interactive = false;
		self.addChild(self.hpBarBg);
		self.addChild(self.hpBar);
		self.updateHpBar();
	};
	self.setHp = function (hp, maxHp) {
		self.hp = hp;
		self.maxHp = maxHp || hp;
		self.updateHpBar();
	};
	self.updateHpBar = function () {
		if (!self.hpBar || !self.hpBarBg) return;
		var ratio = Math.max(0, Math.min(1, self.hp / self.maxHp));
		self.hpBar.width = self.blockSprite.width * 0.78 * ratio;
		// Color changes: green > yellow > red
		if (ratio > 0.66) {
			self.hpBar.tint = 0x44ff44;
		} else if (ratio > 0.33) {
			self.hpBar.tint = 0xffe066;
		} else {
			self.hpBar.tint = 0xff4444;
		}
		self.hpBar.visible = self.hp > 0;
		self.hpBarBg.visible = self.hp > 0;
	};
	self.breakBlock = function () {
		// Animate block breaking
		tween(self, {
			alpha: 0,
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
// Paddle class
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleSprite = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = paddleSprite.width;
	self.height = paddleSprite.height;
	self.moveTo = function (x) {
		// Clamp paddle within game bounds (leave 40px margin)
		var minX = self.width / 2 + 40;
		var maxX = 2048 - self.width / 2 - 40;
		self.x = Math.max(minX, Math.min(maxX, x));
	};
	return self;
});
// PowerUp class
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerSprite = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'expand'; // 'expand', 'shrink', 'life', 'sticky'
	self.vy = 10;
	self.update = function () {
		self.y += self.vy;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Sounds
// Power-up
// Block colors
// Paddle
// Ball
// Game variables
var paddle,
	ball,
	blocks = [],
	powerups = [];
var lives = 3;
var level = 1;
var isBallLaunched = false;
var dragPaddle = false;
var score = 0;
var combo = 0;
var comboTimer = null;
var lastTouchX = 0;
var ballStickyToPaddle = true;
var levelCleared = false;
// GUI
var scoreTxt = new Text2('0', {
	size: 100,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var livesTxt = new Text2('♥♥♥', {
	size: 80,
	fill: 0xFF5E5E
});
livesTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(livesTxt);
var levelTxt = new Text2('Level 1', {
	size: 70,
	fill: 0xFFE066
});
levelTxt.anchor.set(0, 0);
LK.gui.topLeft.addChild(levelTxt);
// Helper: update GUI
function updateGUI() {
	scoreTxt.setText(score);
	var hearts = '';
	for (var i = 0; i < lives; i++) hearts += '♥';
	livesTxt.setText(hearts);
	levelTxt.setText('Level ' + level);
}
// Helper: reset combo
function resetCombo() {
	combo = 0;
	if (comboTimer) {
		LK.clearTimeout(comboTimer);
		comboTimer = null;
	}
}
// Helper: start combo timer
function startCombo() {
	if (comboTimer) LK.clearTimeout(comboTimer);
	comboTimer = LK.setTimeout(function () {
		resetCombo();
	}, 1200);
}
// Helper: spawn blocks for current level
function spawnBlocks() {
	// Remove old blocks
	for (var i = 0; i < blocks.length; i++) {
		blocks[i].destroy();
	}
	blocks = [];
	// Dynamic block pattern logic
	var blockW = 200,
		blockH = 80;
	var marginX = 40,
		marginY = 40;
	var colors = ['red', 'green', 'blue', 'yellow'];
	// Increase rows and columns as level increases, up to a max
	var rows = Math.min(3 + Math.floor(level / 2), 10);
	var cols = Math.min(5 + Math.floor(level / 3), 12);
	// For variety, pick a pattern type based on level
	var patternType = level % 5; // 0: full, 1: checker, 2: pyramid, 3: gaps, 4: zigzag
	var totalW = cols * blockW + (cols - 1) * marginX;
	var startX = (2048 - totalW) / 2 + blockW / 2;
	var startY = 300;
	for (var r = 0; r < rows; r++) {
		for (var c = 0; c < cols; c++) {
			var placeBlock = true;
			// Pattern logic
			if (patternType === 1) {
				// checker
				if ((r + c) % 2 !== 0) placeBlock = false;
			} else if (patternType === 2) {
				// pyramid
				var mid = Math.floor(cols / 2);
				if (c < mid - r || c > mid + r) placeBlock = false;
			} else if (patternType === 3) {
				// random gaps
				if (Math.abs((r * cols + c + level) % 7) === 0) placeBlock = false;
			} else if (patternType === 4) {
				// zigzag
				if (r % 2 === 0 && c % 3 === 0 || r % 2 === 1 && c % 3 === 2) placeBlock = false;
			}
			// patternType 0: full grid
			if (placeBlock) {
				var block = new Block();
				var color = colors[(r + c + level) % colors.length];
				block.setColor(color);
				block.x = startX + c * (blockW + marginX);
				block.y = startY + r * (blockH + marginY);
				// Increase block HP as level increases
				block.hp = 1 + Math.floor(level / 4) + Math.floor(r / 3);
				block.maxHp = block.hp;
				block.setHp(block.hp, block.maxHp);
				game.addChild(block);
				blocks.push(block);
			}
		}
	}
}
// Helper: spawn paddle
function spawnPaddle() {
	if (paddle) paddle.destroy();
	paddle = new Paddle();
	paddle.x = 2048 / 2;
	paddle.y = 2732 - 180;
	game.addChild(paddle);
}
// Helper: spawn ball
function spawnBall() {
	if (ball) ball.destroy();
	ball = new Ball();
	ball.x = paddle.x;
	ball.y = paddle.y - paddle.height / 2 - ball.radius - 10;
	ball.vx = 0;
	ball.vy = 0;
	ball.sticky = true;
	ballStickyToPaddle = true;
	isBallLaunched = false;
	game.addChild(ball);
}
// Helper: spawn powerup
function spawnPowerUp(x, y) {
	var power = new PowerUp();
	var types = ['expand', 'shrink', 'life', 'sticky'];
	power.type = types[Math.floor(Math.random() * types.length)];
	power.x = x;
	power.y = y;
	game.addChild(power);
	powerups.push(power);
}
// Helper: next level
function nextLevel() {
	level++;
	updateGUI();
	spawnBlocks();
	spawnPaddle();
	spawnBall();
	levelCleared = false;
}
// Endless: Remove win condition, always go to nextLevel
// Helper: lose life
function loseLife() {
	lives--;
	updateGUI();
	LK.getSound('lose').play();
	if (lives <= 0) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
		return;
	}
	spawnPaddle();
	spawnBall();
}
// Helper: win
function winGame() {
	LK.effects.flashScreen(0x00ff00, 1000);
	LK.showYouWin();
}
// Initialize first level
spawnBlocks();
spawnPaddle();
spawnBall();
updateGUI();
// Touch controls
game.down = function (x, y, obj) {
	// Only allow paddle drag if touch is near paddle
	if (Math.abs(y - paddle.y) < paddle.height * 2) {
		dragPaddle = true;
		lastTouchX = x;
	}
	// Launch ball if it's sticky
	if (ballStickyToPaddle && dragPaddle) {
		// Launch at slight upward angle based on touch position
		var rel = (x - paddle.x) / (paddle.width / 2);
		var angle = -Math.PI / 3 + rel * (Math.PI / 3); // -60deg to 60deg
		ball.launch(angle);
		isBallLaunched = true;
		ballStickyToPaddle = false;
	}
};
game.move = function (x, y, obj) {
	if (dragPaddle) {
		paddle.moveTo(x);
		// If ball is sticky, move it with paddle
		if (ballStickyToPaddle) {
			ball.x = paddle.x;
		}
	}
};
game.up = function (x, y, obj) {
	dragPaddle = false;
};
// Main update loop
game.update = function () {
	// Ball update
	if (ball) ball.update();
	// PowerUp update
	for (var i = powerups.length - 1; i >= 0; i--) {
		var p = powerups[i];
		p.update();
		// If off screen
		if (p.y > 2732 + 100) {
			p.destroy();
			powerups.splice(i, 1);
			continue;
		}
		// Paddle collision
		if (p.intersects(paddle)) {
			// Apply powerup
			LK.getSound('powerup').play();
			if (p.type === 'expand') {
				tween(paddle, {
					scaleX: 1.5
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				LK.setTimeout(function () {
					tween(paddle, {
						scaleX: 1
					}, {
						duration: 300,
						easing: tween.easeIn
					});
				}, 6000);
			} else if (p.type === 'shrink') {
				tween(paddle, {
					scaleX: 0.7
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				LK.setTimeout(function () {
					tween(paddle, {
						scaleX: 1
					}, {
						duration: 300,
						easing: tween.easeIn
					});
				}, 6000);
			} else if (p.type === 'life') {
				lives = Math.min(5, lives + 1);
				updateGUI();
			} else if (p.type === 'sticky') {
				ball.sticky = true;
				ballStickyToPaddle = true;
				ball.vx = 0;
				ball.vy = 0;
				ball.x = paddle.x;
				ball.y = paddle.y - paddle.height / 2 - ball.radius - 10;
			}
			p.destroy();
			powerups.splice(i, 1);
		}
	}
	// Ball physics
	if (ball && !ball.sticky) {
		// Wall collisions
		if (ball.x - ball.radius < 0) {
			ball.x = ball.radius;
			ball.vx = -ball.vx;
			LK.getSound('hit').play();
		}
		if (ball.x + ball.radius > 2048) {
			ball.x = 2048 - ball.radius;
			ball.vx = -ball.vx;
			LK.getSound('hit').play();
		}
		if (ball.y - ball.radius < 0) {
			ball.y = ball.radius;
			ball.vy = -ball.vy;
			LK.getSound('hit').play();
		}
		// Paddle collision
		if (ball.y + ball.radius >= paddle.y - paddle.height / 2 && ball.y + ball.radius <= paddle.y + paddle.height / 2 && ball.x >= paddle.x - paddle.width / 2 * paddle.scaleX && ball.x <= paddle.x + paddle.width / 2 * paddle.scaleX && ball.vy > 0) {
			// Reflect ball, angle based on where it hit the paddle
			var rel = (ball.x - paddle.x) / (paddle.width / 2 * paddle.scaleX);
			var angle = -Math.PI / 3 + rel * (Math.PI / 3); // -60deg to 60deg
			var speed = Math.sqrt(ball.vx * ball.vx + ball.vy * ball.vy);
			ball.vx = Math.cos(angle) * speed;
			ball.vy = Math.sin(angle) * speed;
			ball.y = paddle.y - paddle.height / 2 - ball.radius - 2;
			LK.getSound('hit').play();
		}
		// Bottom out
		if (ball.y - ball.radius > 2732) {
			loseLife();
			return;
		}
	}
	// Block collisions
	for (var i = blocks.length - 1; i >= 0; i--) {
		var block = blocks[i];
		if (ball && block && ball.intersects(block)) {
			// Reflect ball
			var overlapX = Math.abs(ball.x - block.x) - (block.blockSprite.width / 2 + ball.radius);
			var overlapY = Math.abs(ball.y - block.y) - (block.blockSprite.height / 2 + ball.radius);
			if (overlapX > overlapY) {
				ball.vx = -ball.vx;
			} else {
				ball.vy = -ball.vy;
			}
			// Block hit
			block.hp--;
			if (block.updateHpBar) block.updateHpBar();
			combo++;
			startCombo();
			score += 10 * combo;
			updateGUI();
			LK.getSound('break').play();
			// Power-up chance
			if (Math.random() < 0.12) {
				spawnPowerUp(block.x, block.y);
			}
			if (block.hp <= 0) {
				block.breakBlock();
				blocks.splice(i, 1);
			}
			break; // Only one block per frame
		}
	}
	// Combo reset if no block hit for a while
	if (combo > 0 && !comboTimer) {
		resetCombo();
	}
	// Level clear
	if (!levelCleared && blocks.length === 0) {
		levelCleared = true;
		LK.setTimeout(function () {
			nextLevel();
		}, 1200);
	}
};
// Music (optional, not required by MVP, so not included)
/* End of gamecode.js */