/**** 
* Classes
****/ 
// Initialize rotation speed
//<Assets used in the game will automatically appear here>
// Ball class
var Ball = Container.expand(function () {
	var self = Container.call(this);
	var ballGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.rotationSpeed = 0;
	var half = self.width / 2;
	self.speedX = 3;
	self.speedY = 3;
	self.accelerationY = 0.5; // Gravity
	self.friction = 0.99; // Friction to slow down the ball over time
	self.lastCollisionTime = 0; // Initialize last collision time
	self.update = function (net, player1, player2) {
		if (!ballCanMove) {
			return;
		}
		// Apply gravity
		self.speedY += self.accelerationY;
		// Apply friction
		self.speedX *= self.friction;
		self.speedY *= self.friction;
		// Update ball position
		self.x += self.speedX;
		self.y += self.speedY;
		self.rotation += self.rotationSpeed * (self.speedX > 0 ? 1 : -1); // Update ball rotation based on direction
		self.rotationSpeed *= 0.98; // Gradually decrease rotation speed
		// self.rotation += self.rotationSpeed * (self.speedX > 0 ? 1 : -1); // Update ball rotation based on direction
		// self.rotationSpeed *= 0.98; // Gradually decrease rotation speed
		// Check for out of bounds
		if (self.y + half > 2000) {
			self.y = 2000 - half;
			self.speedY = -Math.abs(self.speedY) * 0.8; // Make the ball bounce up with reduced speed
			playSound('whistle', 1000); // Play whistle sound when ball touches the ground with a cooldown of 1 second
			if (self.x < 1024) {
				score2 += 1; // Increase score for player 2
				scoreTxt2.setText(score2.toString().padStart(2, '0'));
			} else {
				score1 += 1; // Increase score for player 1
				scoreTxt1.setText(score1.toString().padStart(2, '0'));
			}
			resetBall(); // Reset the ball after scoring
			player1Touches = 0;
			player2Touches = 0;
		} else if (self.y - half < 0) {
			self.y = half;
			self.speedY = Math.abs(self.speedY) * 0.8; // Make the ball bounce down with reduced speed
		}
		// Check for x screen limits
		if (self.x - half < 0) {
			self.x = half;
			self.speedX = Math.abs(self.speedX); // Make the ball bounce to the right
		} else if (self.x + half > 2048) {
			self.x = 2048 - half;
			self.speedX = -Math.abs(self.speedX); // Make the ball bounce to the left
		}
		// Collision detection logic moved to game update
	};
});
// Net class
var Net = Container.expand(function () {
	var self = Container.call(this);
	var netGraphics = self.attachAsset('net', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: isDebug ? 1 : 0
	});
});
// Player class
var Player = Container.expand(function (index) {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0.98,
		scaleX: index === 2 ? -1 : 1,
		tint: index === 1 ? 0xADD8E6 : 0xFF6347 // Light blue for player 1, Tomato red for player 2
	});
	self.index = index;
	self.speedX = 0; // Initialize horizontal speed
	var collidSize = 220;
	self.collisionBody = LK.getAsset('collisionBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: isDebug ? 0.6 : 0,
		width: collidSize,
		height: collidSize,
		y: -200
	});
	self.addChild(self.collisionBody);
	self.update = function () {
		var prevX = self.x; // Store previous x position
		var prevY = self.y; // Store previous y position
		if (self.jumping) {
			self.y -= 20; // Increase jump speed
			if (self.y <= 1300) {
				self.jumping = false;
			}
		} else if (self.y < PLAYER1_INITIAL_Y) {
			self.y += 20; // Increase fall speed for smoother jump
		}
		if (self.y >= PLAYER1_INITIAL_Y) {
			self.jumping = false;
			self.y = PLAYER1_INITIAL_Y; // Ensure player lands on the ground
		}
		if (self.y < 0) {
			self.y = 0; // Prevent player1 from moving above the window
		}
		if (self.index === 2 && self.x > 1024 && self.x < 1024 + self.width / 2) {
			self.x = 1024 + self.width / 2; // Prevent player2 from moving past the net
		}
		if (self.index === 2 && self.y >= PLAYER2_INITIAL_Y) {
			self.jumping = false;
			self.y = PLAYER2_INITIAL_Y; // Ensure AI player lands on the ground
		}
		self.speedX = self.x - prevX; // Calculate horizontal speed based on movement
		self.speedY = self.y - prevY; // Calculate vertical speed based on movement
	};
});

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

/**** 
* Game Code
****/ 
var lastPlayedTime = {};
function playSound(soundId, cooldown) {
	var currentTime = Date.now();
	if (!lastPlayedTime[soundId] || currentTime - lastPlayedTime[soundId] > cooldown) {
		LK.getSound(soundId).play();
		lastPlayedTime[soundId] = currentTime;
	}
}
function aiUpdate() {
	// Simple AI to move player2 towards the ball
	if (ball.x > 1024) {
		if (ball.x > player2.x + player2.width / 2) {
			player2.x += 5; // Move right
		} else if (ball.x < player2.x - player2.width / 2) {
			player2.x -= 5; // Move left
		}
	}
	// Make player2 jump if the ball is close
	if (!player2.jumping && player2.y >= PLAYER2_INITIAL_Y && ball.y < player2.y && Math.abs(ball.x - player2.x) < player2.width) {
		player2.jumping = true;
	}
}
function resetBall() {
	ball.x = PLAYER1_INITIAL_X;
	ball.y = 1300; // Set the ball's initial vertical position to y = 1300
	ball.speedX = 3;
	ball.speedY = 3; // Reset speed
	ball.accelerationY = 0.5; // Reset gravity
	ball.friction = 0.99; // Reset friction
	ballCanMove = false; // Reset ball movement flag
	ball.rotation = 0; // Reset rotation angle
	player1Touches = 0;
	player2Touches = 0;
}
function customBoxCircleIntersect(box, circle) {
	var circleX = circle.x;
	var circleY = circle.y;
	if (circle.parent) {
		circleX += circle.parent.x;
		circleY += circle.parent.y;
	}
	var boxX = box.x;
	var boxY = box.y;
	var halfBoxWidth = box.width / 2;
	var halfCircleWidth = circle.width / 2;
	var netBuffer = 2; // Adjust netBuffer to control how far the ball bounces from the net
	// Calculate the coordinates of the box edges with buffer
	var left = boxX - halfBoxWidth;
	var right = boxX + halfBoxWidth;
	var top = boxY - box.height;
	var bottom = boxY;
	// Check if the circle intersects with the box (considering entire ball)
	return circleX + halfCircleWidth > left && circleX - halfCircleWidth < right && circleY + halfCircleWidth > top + netBuffer && circleY - halfCircleWidth < bottom;
}
function customIntersect(circle1, circle2) {
	//console.log("customIntersect  ", circle1, circle2.parent);
	var circle2X = circle2.x;
	var circle2Y = circle2.y;
	if (circle2.parent) {
		circle2X += circle2.parent.x;
		circle2Y += circle2.parent.y;
	}
	var dx = circle1.x - circle2X;
	var dy = circle1.y - circle2Y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var radiusSum = circle1.width / 2 + circle2.width / 2;
	//console.log("customIntersect  ", distance.toFixed(0), radiusSum);
	return distance < radiusSum;
}
var ballCanMove = false;
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
game.addChild(background);
var SPEED_LIMIT = 50; // Define a global speed limit
var isDebug = true;
var player2Debug = false;
var PLAYER1_INITIAL_X = 512;
var PLAYER1_INITIAL_Y = 2000;
var PLAYER2_INITIAL_X = 1536;
var PLAYER2_INITIAL_Y = 2000;
var player1 = new Player(1);
var player2 = new Player(2);
var player1Touches = 0;
var player2Touches = 0;
game.addChild(player1);
game.addChild(player2);
player1.x = PLAYER1_INITIAL_X;
player1.y = PLAYER1_INITIAL_Y;
player2.x = PLAYER2_INITIAL_X;
player2.y = PLAYER2_INITIAL_Y;
var net = new Net();
net.x = 2048 / 2;
net.y = 2000;
game.addChild(net);
var net = new Net();
net.x = 2048 / 2;
net.y = 2000;
game.addChild(net);
var ball = new Ball();
ball.x = PLAYER1_INITIAL_X;
ball.y = 1300; // Set the ball's initial vertical position to y = 1300
ball.rotationSpeed = 0;
game.addChild(ball);
var score1 = 0;
var score2 = 0;
var scoreTxt1 = new Text2('00', {
	size: 200,
	fill: "#00008B",
	fontWeight: "bold"
});
scoreTxt1.anchor.set(-1, 0);
LK.gui.topLeft.addChild(scoreTxt1);
var scoreTxt2 = new Text2('00', {
	size: 200,
	fill: "#FF6347",
	fontWeight: "bold"
});
scoreTxt2.anchor.set(2, 0);
LK.gui.topRight.addChild(scoreTxt2);
game.update = function () {
	if (!ballCanMove && (customIntersect(ball, player1.collisionBody) || customIntersect(ball, player2.collisionBody))) {
		///|| player2.collisionBody && customIntersect(ball, player2.collisionBody) || customIntersect(ball, player1) || customIntersect(ball, player2))) {
		ballCanMove = true;
		//console.log("Player collision detected 1");
	}
	// Check for collision with the net
	if (customBoxCircleIntersect(net, ball)) {
		// Check if enough time has passed since the last collision
		if (Date.now() - ball.lastCollisionTime > 0) {
			playSound('bump', 500); // Play bump sound on collision with a cooldown of 0.5 seconds
			// Reverse ball's horizontal direction and apply some energy loss
			// Handle y reaction when intersecting from the top
			var newSpeedX = ball.speedX * 1.15 + (Math.random() - 0.5) * 0.05;
			var newSpeedY = ball.speedY * 1.15 + (Math.random() - 0.5) * 0.05;
			// Check if the ball is intersecting the net from the top
			//console.log("TOP chceck", ball.y + ball.height / 2, net.y - net.height);
			if (ball.y + ball.height / 2 <= net.y - net.height + 100) {
				console.log("TOP collision detected ", ball.y + ball.height / 2, net.y - net.height);
				// Top collision: Reverse the horizontal direction and limit the speed
				newSpeedX = ball.speedX * 1.25;
				// Top collision: Reverse the vertical direction and limit the speed
				newSpeedY = -Math.min(Math.abs(newSpeedY), SPEED_LIMIT);
			} else {
				// Side collision: Reverse the horizontal direction and limit the speed
				newSpeedX = -Math.sign(newSpeedX) * Math.min(Math.abs(newSpeedX), SPEED_LIMIT);
				newSpeedY = ball.speedY;
			}
			ball.speedX = newSpeedX;
			ball.speedY = newSpeedY;
			// Update the last collision time
			ball.lastCollisionTime = Date.now();
		}
	}
	// Check for collisions with players
	if (customIntersect(ball, player1.collisionBody) || customIntersect(ball, player2.collisionBody)) {
		playSound('bump', 500); // Play bump sound on collision with a cooldown of 0.5 seconds
		// Increment touch counters
		if (customIntersect(ball, player1.collisionBody)) {
			player1Touches++;
			player2Touches = 0; // Reset opponent's touch counter
		} else if (customIntersect(ball, player2.collisionBody)) {
			player2Touches++;
			player1Touches = 0; // Reset opponent's touch counter
		}
		// Check for touch limit
		if (player1Touches >= 4) {
			score2 += 1; // Opponent scores
			scoreTxt2.setText(score2.toString().padStart(2, '0'));
			resetBall();
		} else if (player2Touches >= 4) {
			score1 += 1; // Opponent scores
			scoreTxt1.setText(score1.toString().padStart(2, '0'));
			resetBall();
		}
		//console.log("Player collision detected 2");
		var player = customIntersect(ball, player1.collisionBody) ? player1 : player2;
		var collisionAngle = Math.atan2(ball.y - player.y, ball.x - player.x);
		var speed = Math.sqrt(ball.speedX * ball.speedX + ball.speedY * ball.speedY);
		var playerSpeed = Math.sqrt(player.speedX * player.speedX + player.speedY * player.speedY);
		var newSpeedX = Math.sign(speed * Math.cos(collisionAngle) + (playerSpeed + 0.1 * Math.sign(playerSpeed)) * Math.cos(collisionAngle)) * Math.min(Math.abs(speed * Math.cos(collisionAngle) + (playerSpeed + 0.1 * Math.sign(playerSpeed)) * Math.cos(collisionAngle)), SPEED_LIMIT);
		var newSpeedY = Math.sign(speed * Math.sin(collisionAngle) + (playerSpeed + 0.1 * Math.sign(playerSpeed)) * Math.sin(collisionAngle)) * Math.min(Math.abs(speed * Math.sin(collisionAngle) + (playerSpeed + 0.1 * Math.sign(playerSpeed)) * Math.sin(collisionAngle)), SPEED_LIMIT);
		// Add a bit of randomness to the ball's speed to avoid infinite stuck
		ball.speedX = newSpeedX * 1.20 + (Math.random() - 0.5) * 0.05;
		ball.speedY = newSpeedY * 1.20 + (Math.random() - 0.5) * 0.05;
		//ball.rotationSpeed += Math.sqrt(ball.speedX * ball.speedX + ball.speedY * ball.speedY) * 0.005; // Update rotation speed based on collision
	}
	ball.rotationSpeed = Math.sqrt(ball.speedX * ball.speedX + ball.speedY * ball.speedY) * 0.005; // Update rotation speed based on collision
	aiUpdate();
};
game.down = function (x, y, obj) {
	if (x <= 1024 - player1.width / 2 && x >= player1.width / 2) {
		player1.speedX = x - player1.x; // Update speedX based on movement
		player1.x = x;
	}
	if (player1.y >= PLAYER1_INITIAL_Y) {
		player1.jumping = true;
	}
	if (player2Debug && x >= 1024 + player2.width / 2 && x <= 2048 - player2.width / 2 && x >= player2.width / 2) {
		player2.speedX = x - player2.x; // Update speedX based on movement
		player2.x = x;
	}
	if (player2Debug && player2.y >= PLAYER2_INITIAL_Y) {
		player2.jumping = true;
	}
};
game.move = function (x, y, obj) {
	if (x + player1.width / 2 + net.width / 2 <= 1024 && x - player1.width / 2 >= 0) {
		player1.speedX = x - player1.x; // Update speedX based on movement
		player1.x = x;
	}
	if (player2Debug && x - player2.width / 2 >= 1024 && x + player2.width / 2 <= 2048) {
		player2.speedX = x - player2.x; // Update speedX based on movement
		player2.x = x;
	}
	if (player2Debug && x < 1024 - player2.width / 2) {
		player2.x = 1024 + net.width / 2 + player2.width / 2; // Prevent player2 from moving past the net
	}
	if (player1.y < 0) {
		player1.y = 0; // Prevent player1 from moving above the window
	}
};