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

/**** 
* Classes
****/ 
var Car = Container.expand(function (carType) {
	var self = Container.call(this);
	var carBody = self.attachAsset(carType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 0;
	self.maxSpeed = 200;
	self.acceleration = 0;
	self.rpm = 1000;
	self.gear = 1;
	self.maxGear = 6;
	self.perfectShiftZone = {
		min: 6000,
		max: 6500
	};
	self.redline = 7000;
	self.isRevving = false;
	self.raceStarted = false;
	self.raceFinished = false;
	self.startRevving = function () {
		self.isRevving = true;
	};
	self.stopRevving = function () {
		self.isRevving = false;
	};
	self.shift = function () {
		if (self.gear < self.maxGear && self.raceStarted && !self.raceFinished) {
			var perfect = self.rpm >= self.perfectShiftZone.min && self.rpm <= self.perfectShiftZone.max;
			if (perfect) {
				self.gear++;
				self.rpm = 2000;
				self.acceleration = 0.8;
				LK.getSound('perfectShift').play();
				LK.effects.flashScreen(0x4CAF50, 200);
			} else {
				self.gear++;
				self.rpm = 2000;
				self.acceleration = 0.3;
				LK.getSound('badShift').play();
				LK.effects.flashScreen(0xF44336, 200);
			}
		}
	};
	self.update = function () {
		if (self.raceFinished) return;
		if (self.isRevving && !self.raceStarted) {
			self.rpm += 160;
			if (self.rpm > self.redline) {
				self.rpm = self.redline;
			}
		} else if (!self.isRevving && !self.raceStarted) {
			self.rpm -= 40;
			if (self.rpm < 1000) {
				self.rpm = 1000;
			}
		}
		if (self.raceStarted) {
			var rpmIncrease = 120 / self.gear; // RPM increases slower in higher gears
			self.rpm += rpmIncrease;
			if (self.rpm > self.redline) {
				self.rpm = self.redline;
				self.acceleration = 0.1;
			}
			// Calculate target speed based on RPM and gear
			var rpmRatio = (self.rpm - 1000) / (self.redline - 1000); // Normalize RPM to 0-1
			var gearMaxSpeed = self.maxSpeed * (self.gear / self.maxGear); // Max speed for current gear
			var targetSpeed = rpmRatio * gearMaxSpeed;
			// Rev limiter: when at redline, speed is capped at gear's max speed
			if (self.rpm >= self.redline) {
				targetSpeed = gearMaxSpeed;
			}
			// Gradually adjust speed towards target speed
			if (targetSpeed > self.speed) {
				self.speed += self.acceleration;
			} else {
				self.speed = targetSpeed;
			}
			if (self.speed > self.maxSpeed) {
				self.speed = self.maxSpeed;
			}
			self.x += self.speed * 0.1;
			self.acceleration *= 0.95;
		}
	};
	return self;
});
var OpponentCar = Car.expand(function () {
	var self = Car.call(this, 'opponentCar');
	self.aiShiftTimer = 0;
	self.aiShiftDelay = 90 + Math.random() * 30;
	self.update = function () {
		// Call parent update manually since we're using expand()
		if (self.raceFinished) return;
		if (self.isRevving && !self.raceStarted) {
			self.rpm += 160;
			if (self.rpm > self.redline) {
				self.rpm = self.redline;
			}
		} else if (!self.isRevving && !self.raceStarted) {
			self.rpm -= 40;
			if (self.rpm < 1000) {
				self.rpm = 1000;
			}
		}
		if (self.raceStarted) {
			var rpmIncrease = 120 / self.gear; // RPM increases slower in higher gears
			self.rpm += rpmIncrease;
			if (self.rpm > self.redline) {
				self.rpm = self.redline;
				self.acceleration = 0.1;
			}
			// Calculate target speed based on RPM and gear
			var rpmRatio = (self.rpm - 1000) / (self.redline - 1000); // Normalize RPM to 0-1
			var gearMaxSpeed = self.maxSpeed * (self.gear / self.maxGear); // Max speed for current gear
			var targetSpeed = rpmRatio * gearMaxSpeed;
			// Rev limiter: when at redline, speed is capped at gear's max speed
			if (self.rpm >= self.redline) {
				targetSpeed = gearMaxSpeed;
			}
			// Gradually adjust speed towards target speed
			if (targetSpeed > self.speed) {
				self.speed += self.acceleration;
			} else {
				self.speed = targetSpeed;
			}
			if (self.speed > self.maxSpeed) {
				self.speed = self.maxSpeed;
			}
			self.x += self.speed * 0.1;
			self.acceleration *= 0.95;
		}
		if (self.raceStarted && !self.raceFinished) {
			self.aiShiftTimer++;
			if (self.aiShiftTimer >= self.aiShiftDelay && self.gear < self.maxGear) {
				// Opponent car shifts automatically with consistent performance
				self.gear++;
				self.rpm = 2000;
				self.acceleration = 0.6 + Math.random() * 0.2; // Random performance between 0.6-0.8
				self.aiShiftTimer = 0;
				self.aiShiftDelay = 80 + Math.random() * 40;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var currentRace = 1;
var maxRaces = 10;
var raceState = 'countdown';
var countdownTimer = 0;
var startLightTimer = 0;
var perfectStartWindow = false;
var engineSound = null;
var lastRpm = 1000;
var track = game.attachAsset('track', {
	anchorX: 0,
	anchorY: 0.5,
	x: 0,
	y: 1366
});
var startLine = game.attachAsset('startLine', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 300,
	y: 1366
});
var finishLine = game.attachAsset('finishLine', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1748,
	y: 1366
});
var playerCar = game.addChild(new Car('playerCar'));
playerCar.x = 250;
playerCar.y = 1340;
var opponentCar = game.addChild(new OpponentCar());
opponentCar.x = 250;
opponentCar.y = 1390;
var rpmGauge = game.attachAsset('rpmGauge', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1600
});
var perfectZone = game.attachAsset('perfectZone', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1150,
	y: 1600
});
var rpmNeedle = game.attachAsset('rpmNeedle', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 824,
	y: 1600
});
var redLight = game.attachAsset('redLight', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 600
});
var greenLight = game.attachAsset('greenLight', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 600,
	alpha: 0
});
var speedText = new Text2('0 MPH', {
	size: 80,
	fill: 0xFFFFFF
});
speedText.anchor.set(0.5, 0);
speedText.x = 1024;
speedText.y = 1700;
game.addChild(speedText);
var gearText = new Text2('GEAR: 1', {
	size: 60,
	fill: 0xFFFFFF
});
gearText.anchor.set(0.5, 0);
gearText.x = 1024;
gearText.y = 1500;
game.addChild(gearText);
var raceText = new Text2('RACE ' + currentRace, {
	size: 100,
	fill: 0xFFFFFF
});
raceText.anchor.set(0.5, 0.5);
raceText.x = 1024;
raceText.y = 300;
game.addChild(raceText);
var instructionText = new Text2('HOLD TO REV - RELEASE ON GREEN', {
	size: 50,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0.5);
instructionText.x = 1024;
instructionText.y = 800;
game.addChild(instructionText);
function startCountdown() {
	raceState = 'countdown';
	countdownTimer = 0;
	startLightTimer = 0;
	redLight.alpha = 1;
	greenLight.alpha = 0;
	LK.setTimeout(function () {
		redLight.alpha = 0;
		greenLight.alpha = 1;
		perfectStartWindow = true;
		instructionText.setText('TAP TO SHIFT IN GREEN ZONE');
		LK.getSound('raceStart').play();
		LK.setTimeout(function () {
			raceState = 'racing';
			playerCar.raceStarted = true;
			opponentCar.raceStarted = true;
			var launchQuality = 0.5;
			if (playerCar.rpm >= 4000 && playerCar.rpm <= 5000) {
				launchQuality = 1.0;
			} else if (playerCar.rpm >= 3000 && playerCar.rpm <= 6000) {
				launchQuality = 0.8;
			}
			playerCar.acceleration = launchQuality;
			opponentCar.acceleration = 0.8 + Math.random() * 0.2;
			perfectStartWindow = false;
		}, 500);
	}, 3000);
}
function resetRace() {
	raceState = 'countdown';
	playerCar.x = 250;
	playerCar.y = 1340;
	playerCar.speed = 0;
	playerCar.rpm = 1000;
	playerCar.gear = 1;
	playerCar.acceleration = 0;
	playerCar.raceStarted = false;
	playerCar.raceFinished = false;
	playerCar.isRevving = false;
	opponentCar.x = 250;
	opponentCar.y = 1390;
	opponentCar.speed = 0;
	opponentCar.rpm = 1000;
	opponentCar.gear = 1;
	opponentCar.acceleration = 0;
	opponentCar.raceStarted = false;
	opponentCar.raceFinished = false;
	opponentCar.aiShiftTimer = 0;
	raceText.setText('RACE ' + currentRace);
	instructionText.setText('HOLD TO REV - RELEASE ON GREEN');
	startCountdown();
}
game.down = function (x, y, obj) {
	if (raceState === 'countdown') {
		playerCar.startRevving();
		LK.getSound('engineRev').play();
	} else if (raceState === 'racing') {
		// Only player car shifting is controlled by player input
		playerCar.shift();
	}
};
game.up = function (x, y, obj) {
	if (raceState === 'countdown') {
		playerCar.stopRevving();
	}
};
game.update = function () {
	var needlePosition = 824 + (playerCar.rpm - 1000) / 6000 * 400;
	if (needlePosition > 1224) needlePosition = 1224;
	if (needlePosition < 824) needlePosition = 824;
	rpmNeedle.x = needlePosition;
	speedText.setText(Math.floor(playerCar.speed * 2) + ' MPH');
	gearText.setText('GEAR: ' + playerCar.gear);
	// Engine sound pitch control based on RPM
	if (playerCar.raceStarted || playerCar.isRevving) {
		if (!engineSound || !engineSound.isPlaying) {
			engineSound = LK.getSound('engineSound');
			engineSound.play();
		}
		// Calculate pitch based on RPM (1000-7000 RPM maps to 0.5-500.0 pitch)
		var rpmRange = playerCar.redline - 1000; // 6000
		var currentRpmNormalized = (playerCar.rpm - 1000) / rpmRange; // 0-1
		var targetPitch = 0.5 + currentRpmNormalized * 499.5; // 0.5-500.0
		// Smooth pitch transitions
		if (engineSound && engineSound.setPitch) {
			engineSound.setPitch(targetPitch);
		}
		lastRpm = playerCar.rpm;
	} else {
		// Stop engine sound when not racing or revving
		if (engineSound && engineSound.isPlaying) {
			engineSound.stop();
			engineSound = null;
		}
	}
	if (raceState === 'racing') {
		if (playerCar.x >= 1700 && !playerCar.raceFinished) {
			playerCar.raceFinished = true;
			opponentCar.raceFinished = true;
			if (currentRace < maxRaces) {
				currentRace++;
				LK.setScore(currentRace - 1);
				LK.setTimeout(function () {
					resetRace();
				}, 2000);
			} else {
				LK.showYouWin();
			}
		} else if (opponentCar.x >= 1700 && !opponentCar.raceFinished) {
			playerCar.raceFinished = true;
			opponentCar.raceFinished = true;
			LK.showGameOver();
		}
	}
};
startCountdown();