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

/**** 
* Classes
****/ 
var BotCar = Container.expand(function (carIndex) {
	var self = Container.call(this);
	// Use different car assets based on car index
	var carAssetName = 'botCar' + (carIndex % 8 + 1);
	var carGraphics = self.attachAsset(carAssetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.baseSpeed = Math.random() * 8 + 12; // Random speed between 12-20 (player speed level)
	self.currentSpeed = 0; // Start stationary until race begins
	self.lanePosition = Math.floor(Math.random() * 3); // 0=left, 1=center, 2=right
	self.targetX = 400 + self.lanePosition * 600; // Lane positions
	self.aiTimer = 0;
	self.carNumber = carIndex + 1;
	self.isChangingLanes = false; // Track lane changing state
	// Assign different colors to each bot car
	var colors = [0x0066ff, 0x00ff66, 0xff6600, 0xff0066, 0x6600ff, 0xffff00, 0x00ffff, 0xff00ff];
	carGraphics.tint = colors[carIndex % colors.length];
	self.lapCount = 1;
	self.raceDistance = 0;
	self.hasFinished = false;
	self.update = function () {
		// Only move if race has started
		if (!raceStarted) {
			return;
		}
		// AI behavior - change lanes occasionally
		self.aiTimer++;
		if (self.aiTimer > 120 && Math.random() < 0.03 && !self.isChangingLanes) {
			// Every 2 seconds, 3% chance, only if not already changing lanes
			self.aiTimer = 0;
			var newLane = Math.floor(Math.random() * 3);
			if (newLane !== self.lanePosition) {
				self.lanePosition = newLane;
				self.targetX = 400 + self.lanePosition * 600;
				self.isChangingLanes = true;
				// Smooth lane change with tween and rotation
				var direction = self.targetX > self.x ? 1 : -1;
				// Add slight rotation during lane change for stability (reduced rotation)
				tween(carGraphics, {
					rotation: direction * 0.05
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Return to straight after lane change (faster return)
						tween(carGraphics, {
							rotation: 0
						}, {
							duration: 150,
							easing: tween.easeInOut
						});
					}
				});
				// Smooth X movement (faster lane change)
				tween(self, {
					x: self.targetX
				}, {
					duration: 400,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						self.isChangingLanes = false;
					}
				});
			}
		}
		// Check for collision with other bot cars before moving
		var canMove = true;
		for (var b = 0; b < botCars.length; b++) {
			var otherBot = botCars[b];
			if (otherBot !== self && otherBot.intersects && Math.abs(otherBot.x - self.x) < 200 && Math.abs(otherBot.y - self.y) < 400) {
				// Too close to another bot car, slow down or change lanes
				if (otherBot.y < self.y) {
					// Bot ahead, slow down
					self.currentSpeed = Math.max(5, self.currentSpeed - 2);
					canMove = false;
				}
			}
		}
		// Move forward (relative to player) - faster movement
		if (canMove) {
			self.y += raceSpeed - self.currentSpeed;
		} else {
			self.y += raceSpeed - self.currentSpeed * 0.5; // Move slower when blocked
		}
		// Keep within screen bounds
		if (self.x < 100) {
			self.x = 100;
		}
		if (self.x > 1948) {
			self.x = 1948;
		}
		// Track bot lap progress
		if (!self.hasFinished) {
			self.raceDistance += self.currentSpeed;
			if (self.raceDistance >= lapDistance) {
				self.raceDistance = 0;
				self.lapCount++;
				// Finish after completing 10 laps
				if (self.lapCount > 10) {
					self.hasFinished = true;
					botsFinished++;
				}
			}
		}
	};
	return self;
});
var FinishLine = Container.expand(function () {
	var self = Container.call(this);
	// Create left pole
	var leftPole = self.attachAsset('finishPole', {
		anchorX: 0.5,
		anchorY: 1
	});
	leftPole.x = -800;
	leftPole.y = 0;
	// Create right pole  
	var rightPole = self.attachAsset('finishPole', {
		anchorX: 0.5,
		anchorY: 1
	});
	rightPole.x = 800;
	rightPole.y = 0;
	// Create checkered pattern
	for (var i = 0; i < 16; i++) {
		for (var j = 0; j < 2; j++) {
			var isBlack = (i + j) % 2 === 0;
			var square = self.attachAsset(isBlack ? 'checkeredSquare1' : 'checkeredSquare2', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			square.x = (i - 7.5) * 100;
			square.y = (j - 0.5) * 40;
		}
	}
	self.update = function () {
		self.y += raceSpeed;
	};
	return self;
});
var PlayerCar = Container.expand(function () {
	var self = Container.call(this);
	var carGraphics = self.attachAsset('playerCar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.maxSpeed = 350;
	self.acceleration = 0.2;
	self.currentSpeed = 0;
	self.update = function () {
		// Simulate acceleration/deceleration based on movement
		if (Math.abs(self.lastX - self.x) > 5) {
			self.currentSpeed = Math.min(self.maxSpeed, self.currentSpeed + self.acceleration);
		} else {
			self.currentSpeed = Math.max(0, self.currentSpeed - self.acceleration * 0.5);
		}
		self.lastX = self.x;
	};
	return self;
});
var RoadLine = Container.expand(function () {
	var self = Container.call(this);
	var lineGraphics = self.attachAsset('roadLine', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.update = function () {
		self.y += raceSpeed;
	};
	return self;
});
var TrackEdge = Container.expand(function (barrierIndex) {
	var self = Container.call(this);
	// Use different barrier assets based on index (1-5)
	var barrierAssetName = 'trackBarrier' + (barrierIndex % 5 + 1);
	var edgeGraphics = self.attachAsset(barrierAssetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.y += raceSpeed;
	};
	return self;
});
var TrafficLight = Container.expand(function () {
	var self = Container.call(this);
	// Create larger frame background (5x bigger to fit 5 lights)
	var lightBackground = self.attachAsset('trafficLight', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	lightBackground.scaleX = 5;
	lightBackground.scaleY = 3;
	// Create 5 lights in a horizontal row
	self.lights = [];
	for (var i = 0; i < 5; i++) {
		var light = self.attachAsset('lightRed', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		light.scaleX = 2;
		light.scaleY = 2;
		light.x = (i - 2) * 160; // Space lights 160 pixels apart so they barely touch (80px radius * 2 scale * 2 = 160px diameter)
		light.alpha = 1.0;
		light.tint = 0xff0000; // Start all red
		self.lights.push(light);
	}
	self.setAllRed = function () {
		for (var i = 0; i < self.lights.length; i++) {
			self.lights[i].tint = 0xff0000; // Red color
			// Add glow effect with tween
			tween(self.lights[i], {
				scaleX: 2.3,
				scaleY: 2.3
			}, {
				duration: 200,
				easing: tween.easeOut
			});
		}
	};
	self.setLightGreen = function (lightIndex) {
		if (lightIndex >= 0 && lightIndex < self.lights.length) {
			var light = self.lights[lightIndex];
			light.tint = 0x00ff00; // Green color
			light.alpha = 1.0; // Ensure full visibility
			// Force the light to render on top by moving to front
			self.removeChild(light);
			self.addChild(light);
			// Add glow effect with tween
			tween(light, {
				scaleX: 2.3,
				scaleY: 2.3
			}, {
				duration: 200,
				easing: tween.easeOut
			});
		}
	};
	self.setOff = function () {
		for (var i = 0; i < self.lights.length; i++) {
			self.lights[i].alpha = 0.2;
			// Reset scale
			self.lights[i].scaleX = 2;
			self.lights[i].scaleY = 2;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var botCars = [];
var roadLines = [];
var finishLines = [];
var trackEdges = [];
var botSpawnTimer = 0;
var lineSpawnTimer = 0;
var checkpointTimer = 0;
var raceSpeed = 8;
var lapNumber = 1;
var position = 9; // Starting position (9th out of 9)
var raceDistance = 0;
var lapDistance = 5000; // Distance for one lap
var raceFinished = false;
var finalPosition = 9;
var botsFinished = 0;
var raceStarted = false;
var trafficLights = [];
var lightSequenceStep = 0;
var lightSequenceTimer = 0;
var raceStartSequence = false;
var startText = null;
// UI Elements  
var positionTxt = new Text2('Position: 9/9', {
	size: 50,
	fill: 0xFFFFFF
});
positionTxt.anchor.set(0, 0);
LK.gui.topLeft.addChild(positionTxt);
positionTxt.x = 120;
positionTxt.y = 20;
var lapTxt = new Text2('Lap: 1/10', {
	size: 40,
	fill: 0xFFFF00
});
lapTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(lapTxt);
lapTxt.x = -20;
lapTxt.y = 20;
var speedTxt = new Text2('Speed: 0', {
	size: 35,
	fill: 0x00FF00
});
speedTxt.anchor.set(0, 0);
LK.gui.topLeft.addChild(speedTxt);
speedTxt.x = 120;
speedTxt.y = 80;
// Initialize player
player = new PlayerCar();
player.x = 1300;
player.y = 2450; // Player starts at the back of the vertical line
player.lastX = player.x;
game.addChild(player);
// Create starting grid with 8 bot cars in vertical single-file line
var startingPositions = [
// Position 1 (pole position)
{
	x: 700,
	y: 500
},
// Position 2
{
	x: 700,
	y: 1050
},
// Position 3
{
	x: 700,
	y: 1600
},
// Position 4
{
	x: 700,
	y: 2150
},
// Position 5
{
	x: 1300,
	y: 250
},
// Position 6
{
	x: 1300,
	y: 800
},
// Position 7
{
	x: 1300,
	y: 1350
},
// Position 8
{
	x: 1300,
	y: 1900
} // Last position
];
for (var i = 0; i < 8; i++) {
	var bot = new BotCar(i);
	bot.x = startingPositions[i].x;
	bot.y = startingPositions[i].y;
	bot.startingPosition = i + 1;
	botCars.push(bot);
	game.addChild(bot);
}
// Create 5-light traffic light system
var trafficLight = new TrafficLight();
trafficLight.x = 1024; // Center of screen
trafficLight.y = 600;
trafficLight.setAllRed();
trafficLights.push(trafficLight);
game.addChild(trafficLight);
// Create start text (initially hidden)
startText = new Text2('START!', {
	size: 120,
	fill: 0x00ff00
});
startText.anchor.set(0.5, 0.5);
startText.x = 1024;
startText.y = 1000;
startText.alpha = 0;
game.addChild(startText);
// Start the light sequence after 1 second
LK.setTimeout(function () {
	raceStartSequence = true;
}, 1000);
// Create track barriers - 5 continuous barriers on each side with no gaps
var leftBarriers = [];
var rightBarriers = [];
for (var i = 0; i < 5; i++) {
	// Left side barriers
	var leftBarrier = new TrackEdge(i);
	leftBarrier.x = 150;
	leftBarrier.y = i * 546 - 200; // Position barriers adjacently based on barrier height (546px)
	leftBarrier.side = 'left';
	leftBarriers.push(leftBarrier);
	trackEdges.push(leftBarrier);
	game.addChild(leftBarrier);
	// Right side barriers
	var rightBarrier = new TrackEdge(i);
	rightBarrier.x = 1898;
	rightBarrier.y = i * 546 - 200; // Position barriers adjacently based on barrier height (546px)
	rightBarrier.side = 'right';
	rightBarriers.push(rightBarrier);
	trackEdges.push(rightBarrier);
	game.addChild(rightBarrier);
}
// Create initial road lines (add to background first)
for (var i = 0; i < 15; i++) {
	var line1 = new RoadLine();
	line1.x = 700;
	line1.y = i * 200 - 100;
	roadLines.push(line1);
	game.addChildAt(line1, 0);
	var line2 = new RoadLine();
	line2.x = 1300;
	line2.y = i * 200 - 100;
	roadLines.push(line2);
	game.addChildAt(line2, 0);
}
// Input handling
var dragTarget = null;
game.down = function (x, y, obj) {
	dragTarget = player;
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	dragTarget = null;
};
function handleMove(x, y, obj) {
	if (dragTarget) {
		dragTarget.x = x;
		// Keep player within racing lanes
		if (dragTarget.x < 300) {
			dragTarget.x = 300;
		}
		if (dragTarget.x > 1748) {
			dragTarget.x = 1748;
		}
		// Increase speed based on movement
		if (Math.abs(dragTarget.x - dragTarget.lastX) > 5) {
			raceSpeed = Math.min(25, raceSpeed + 0.2);
		}
	}
}
game.move = handleMove;
// Spawn bot car function
function spawnBotCar() {
	var carIndex = Math.floor(Math.random() * 8);
	var bot = new BotCar(carIndex);
	bot.x = 400 + Math.floor(Math.random() * 3) * 600; // Random lane
	bot.y = -100;
	botCars.push(bot);
	game.addChild(bot);
}
// Spawn road lines function
function spawnRoadLines() {
	var line1 = new RoadLine();
	line1.x = 700;
	line1.y = -50;
	roadLines.push(line1);
	game.addChildAt(line1, 0);
	var line2 = new RoadLine();
	line2.x = 1300;
	line2.y = -50;
	roadLines.push(line2);
	game.addChildAt(line2, 0);
}
// Main game update
game.update = function () {
	// Only update race mechanics if race has started
	if (raceStarted) {
		// Update race distance
		raceDistance += raceSpeed;
		// Update speed display (scale to show realistic racing speeds)
		speedTxt.setText('Speed: ' + Math.floor(raceSpeed * 10) + ' km/h');
	} else {
		// Show stationary speed during countdown
		speedTxt.setText('Speed: 0');
	}
	// Only handle race mechanics if race has started
	if (raceStarted) {
		// Check for lap completion or finish line crossing
		if (raceDistance >= lapDistance && !raceFinished) {
			raceDistance = 0;
			lapNumber++;
			lapTxt.setText('Lap: ' + lapNumber + '/10');
			LK.getSound('checkpoint').play();
		}
	}
	// Check for race completion after lap 10
	if (lapNumber >= 10 && !raceFinished) {
		raceFinished = true;
		finalPosition = botsFinished + 1; // Player finishes after bots that already finished
		// Show single checkered flag at finish line
		var finishFlag = new FinishLine();
		finishFlag.x = 1024; // Center of screen
		finishFlag.y = -200; // Start above screen
		finishLines.push(finishFlag);
		game.addChild(finishFlag);
		// Create result text
		var resultTxt = new Text2('Race Finished!\nFinal Position: ' + finalPosition + '/9\nLaps Completed: 10', {
			size: 60,
			fill: 0xFFFFFF,
			align: 'center'
		});
		resultTxt.anchor.set(0.5, 0.5);
		resultTxt.x = 1024;
		resultTxt.y = 1366;
		game.addChild(resultTxt);
		LK.setScore(900 - finalPosition * 100); // Higher score for better position
		// Show you win after 3 seconds
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 3000);
	}
	// Handle traffic light sequence
	if (raceStartSequence && !raceStarted) {
		lightSequenceTimer++;
		// Turn lights green one by one every 60 frames (1 second each)
		if (lightSequenceTimer === 60) {
			// First light turns green after 1 second
			trafficLights[0].setLightGreen(0);
		} else if (lightSequenceTimer === 120) {
			// Second light turns green after 2 seconds
			trafficLights[0].setLightGreen(1);
		} else if (lightSequenceTimer === 180) {
			// Third light turns green after 3 seconds
			trafficLights[0].setLightGreen(2);
		} else if (lightSequenceTimer === 240) {
			// Fourth light turns green after 4 seconds
			trafficLights[0].setLightGreen(3);
		} else if (lightSequenceTimer === 300) {
			// Fifth light turns green after 5 seconds - RACE STARTS
			trafficLights[0].setLightGreen(4);
			// Show START text with tween animation
			tween(startText, {
				alpha: 1,
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 500,
				easing: tween.bounceOut,
				onFinish: function onFinish() {
					// Fade out start text after 1 second
					tween(startText, {
						alpha: 0
					}, {
						duration: 1000
					});
				}
			});
			raceStarted = true;
			// Activate bot cars with adjusted speeds
			for (var i = 0; i < botCars.length; i++) {
				botCars[i].currentSpeed = botCars[i].baseSpeed;
				// Add slight speed variation for more realistic racing
				botCars[i].currentSpeed += Math.random() * 2 - 1; // +/- 1 speed variation (much smaller range)
			}
			// Hide traffic light with animation
			tween(trafficLights[0], {
				alpha: 0,
				y: trafficLights[0].y - 100
			}, {
				duration: 1000,
				easing: tween.easeOut
			});
		}
	}
	// Spawn road lines
	lineSpawnTimer++;
	if (lineSpawnTimer >= 25) {
		lineSpawnTimer = 0;
		spawnRoadLines();
	}
	// Update and check bot cars
	for (var i = botCars.length - 1; i >= 0; i--) {
		var bot = botCars[i];
		if (bot.lastY === undefined) {
			bot.lastY = bot.y;
		}
		if (bot.lastIntersecting === undefined) {
			bot.lastIntersecting = false;
		}
		// Remove bots that go off screen
		if (bot.lastY <= 2800 && bot.y > 2800) {
			bot.destroy();
			botCars.splice(i, 1);
			continue;
		}
		// Check collision with player
		var currentIntersecting = bot.intersects(player);
		if (!bot.lastIntersecting && currentIntersecting) {
			LK.getSound('collision').play();
			// Slow down both cars on collision
			raceSpeed = Math.max(3, raceSpeed - 2);
			// Move player away from collision
			if (player.x < bot.x) {
				player.x -= 30;
			} else {
				player.x += 30;
			}
		}
		bot.lastY = bot.y;
		bot.lastIntersecting = currentIntersecting;
	}
	// Update road lines
	for (var i = roadLines.length - 1; i >= 0; i--) {
		var line = roadLines[i];
		if (line.lastY === undefined) {
			line.lastY = line.y;
		}
		// Remove lines that go off screen
		if (line.lastY <= 2800 && line.y > 2800) {
			line.destroy();
			roadLines.splice(i, 1);
			continue;
		}
		line.lastY = line.y;
	}
	// Update track edges and check collisions
	for (var i = trackEdges.length - 1; i >= 0; i--) {
		var edge = trackEdges[i];
		if (edge.lastY === undefined) {
			edge.lastY = edge.y;
		}
		// Check collision with player
		if (edge.intersects && edge.intersects(player)) {
			// Play collision sound
			LK.getSound('collision').play();
			// Reduce speed significantly
			raceSpeed = Math.max(2, raceSpeed - 4);
			// Bounce player away from barrier
			if (edge.side === 'left') {
				// Hit left barrier, push player right
				tween(player, {
					x: player.x + 100
				}, {
					duration: 300,
					easing: tween.easeOut
				});
			} else if (edge.side === 'right') {
				// Hit right barrier, push player left
				tween(player, {
					x: player.x - 100
				}, {
					duration: 300,
					easing: tween.easeOut
				});
			}
			// Flash the barrier red to show collision
			tween(edge, {
				tint: 0xff0000
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(edge, {
						tint: 0xffffff
					}, {
						duration: 300,
						easing: tween.easeIn
					});
				}
			});
		}
		// Check collisions with bot cars
		for (var j = 0; j < botCars.length; j++) {
			var bot = botCars[j];
			if (edge.intersects && edge.intersects(bot)) {
				// Reduce bot speed
				bot.currentSpeed = Math.max(2, bot.currentSpeed - 3);
				// Bounce bot away from barrier
				if (edge.side === 'left') {
					// Hit left barrier, push bot right
					tween(bot, {
						x: bot.x + 80
					}, {
						duration: 250,
						easing: tween.easeOut
					});
				} else if (edge.side === 'right') {
					// Hit right barrier, push bot left
					tween(bot, {
						x: bot.x - 80
					}, {
						duration: 250,
						easing: tween.easeOut
					});
				}
			}
		}
		// Remove edges that go off screen and spawn new ones
		if (edge.lastY <= 2800 && edge.y > 2800) {
			edge.destroy();
			trackEdges.splice(i, 1);
			continue;
		}
		edge.lastY = edge.y;
	}
	// Update finish lines
	for (var i = finishLines.length - 1; i >= 0; i--) {
		var finishLine = finishLines[i];
		if (finishLine.lastY === undefined) {
			finishLine.lastY = finishLine.y;
		}
		// Remove finish lines that go off screen
		if (finishLine.lastY <= 2800 && finishLine.y > 2800) {
			finishLine.destroy();
			finishLines.splice(i, 1);
			continue;
		}
		finishLine.lastY = finishLine.y;
	}
	// Spawn new track barriers - maintain continuous coverage with no gaps
	if (LK.ticks % 40 === 0) {
		// Spawn more frequently to ensure continuous coverage
		var barrierIndex = Math.floor(Math.random() * 5);
		// Find the topmost barrier position for each side to place new ones adjacent
		var leftTopY = -400;
		var rightTopY = -400;
		// Find the highest (lowest Y value) barrier on each side
		for (var k = 0; k < leftBarriers.length; k++) {
			if (leftBarriers[k].y < leftTopY) {
				leftTopY = leftBarriers[k].y;
			}
		}
		for (var k = 0; k < rightBarriers.length; k++) {
			if (rightBarriers[k].y < rightTopY) {
				rightTopY = rightBarriers[k].y;
			}
		}
		var leftBarrier = new TrackEdge(barrierIndex);
		leftBarrier.x = 150;
		// Position new barrier to be adjacent to the topmost barrier (accounting for barrier height)
		leftBarrier.y = leftTopY - 546; // Use barrier height to ensure no gap
		leftBarrier.side = 'left';
		leftBarriers.push(leftBarrier);
		trackEdges.push(leftBarrier);
		game.addChild(leftBarrier);
		var rightBarrier = new TrackEdge(barrierIndex);
		rightBarrier.x = 1898;
		// Position new barrier to be adjacent to the topmost barrier (accounting for barrier height)
		rightBarrier.y = rightTopY - 546; // Use barrier height to ensure no gap
		rightBarrier.side = 'right';
		rightBarriers.push(rightBarrier);
		trackEdges.push(rightBarrier);
		game.addChild(rightBarrier);
		// Remove barriers from arrays when they go off screen
		for (var k = leftBarriers.length - 1; k >= 0; k--) {
			if (leftBarriers[k].y > 2800) {
				leftBarriers.splice(k, 1);
			}
		}
		for (var k = rightBarriers.length - 1; k >= 0; k--) {
			if (rightBarriers[k].y > 2800) {
				rightBarriers.splice(k, 1);
			}
		}
	}
	// Calculate position based on bot cars behind player and finished bots
	if (!raceFinished && raceStarted) {
		var carsAhead = botsFinished; // Count finished bots as ahead
		for (var i = 0; i < botCars.length; i++) {
			var bot = botCars[i];
			if (!bot.hasFinished) {
				// Compare lap progress for unfinished bots
				if (bot.lapCount > lapNumber || bot.lapCount === lapNumber && bot.raceDistance > raceDistance) {
					carsAhead++;
				}
			}
		}
		position = Math.max(1, Math.min(9, carsAhead + 1)); // Clamp position between 1-9
		positionTxt.setText('Position: ' + position + '/9');
	} else if (raceFinished) {
		positionTxt.setText('Position: ' + finalPosition + '/9 - FINISHED');
	} else {
		// Before race starts, show starting position
		positionTxt.setText('Position: 9/9');
	}
	// Gradually increase race speed
	if (LK.ticks % 300 === 0) {
		// Every 5 seconds
		raceSpeed = Math.min(12, raceSpeed + 0.1);
	}
};