/**** 
* Classes
****/ 
var BootText = Container.expand(function (text) {
	var self = Container.call(this);
	var bootText = self.addChild(new Text2(text, {
		size: 100,
		fill: "#FFFFFF",
		fontWeight: 'bolder'
	}));
	bootText.anchor.set(0.5, 0);
	self.alpha = 0;
	self.fadeIn = function () {
		if (self.alpha < 1) {
			self.alpha += 0.05;
		}
	};
	self.fadeOut = function () {
		if (self.alpha > 0) {
			self.alpha -= 0.05;
		} else {
			self.destroy();
		}
	};
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -3;
	self._move_migrated = function () {};
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	self.createDashTrail = function () {
		var trailCount = 10;
		var flashDuration = 50; // Duration for each flash
		for (var i = 0; i < trailCount; i++) {
			LK.setTimeout(function () {
				var trailParticle = new Particle();
				trailParticle.x = self.x;
				trailParticle.y = self.y;
				game.addChild(trailParticle);
				LK.effects.flashObject(trailParticle, 0x00ff00, flashDuration);
			}, i * 50);
		}
	};
	var heroGraphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 30;
	self.dashSpeed = game.width / 2 / 30; // 1/2 of the screen over 0.5 seconds at 60FPS
	self.dashBackSpeed = self.dashSpeed / 2; // Accelerated return at half of the dash speed
	self.dashStartTime = 0; // Time when the dash started
	self.gravity = 1;
	self.isDashing = false;
	self.initialX = 200;
	self.animateToPosition = function () {
		var targetY = 2732 / 2;
		var targetX = self.initialX;
		var animationSpeed = 10;
		if (!self.animationStarted) {
			self.animationDelay = LK.setTimeout(function () {
				self.animationStarted = true;
			}, 3000);
			self.animationStarted = false;
		}
		if (self.animationStarted) {
			if (self.y < targetY) {
				self.y += animationSpeed;
			}
			if (self.x < targetX) {
				self.x += animationSpeed;
			}
			if (self.y >= targetY && self.x >= targetX) {
				gameStarted = true; // Start the game once the hero reaches the initial position
				initializeScoreDisplay();
				startObstacleGeneration();
			}
		}
	};
	self.dash = function () {
		if (!self.isDashing && LK.ticks - self.holdStartTime >= 60 && self.x === self.initialX) {
			self.isDashing = true;
			self.dashStartTime = LK.ticks; // Save the start time of the dash
			self.savedX = self.x; // Save the current x position
			self.dashTargetX = self.x + game.width / 3 * 2; // Set the target X position for the dash, now twice as long
			// Apply dash effect
			self.createDashTrail();
		}
	};
	self.isGravityFlipped = false;
	self.flipGravity = function () {
		self.isGravityFlipped = !self.isGravityFlipped;
		self.gravity *= -1;
	};
	self._move_migrated = function () {
		if (self.isHolding && LK.ticks - self.holdStartTime >= 60 && LK.ticks - self.dashStartTime > 6) {
			self.dash();
		}
		if (self.isDashing) {
			if (self.x < self.dashTargetX) {
				self.x += self.dashSpeed;
				// Check for collision with obstacles
				for (var i = obstacles.length - 1; i >= 0; i--) {
					if (self.intersects(obstacles[i])) {
						obstacles[i].destroy();
						obstacles.splice(i, 1);
					}
				}
			} else {
				self.isDashing = false;
				self.dashTargetX = null; // Clear the dash target position
				// Remove dash effect
				self.tint = 0xffffff;
			}
		}
		// Gradually move back to the initial position after dashing
		// Resume normal movement after reaching saved x position
		if (!self.isDashing && self.dashTargetX === null && self.x !== self.savedX) {
			var moveBack = self.savedX < self.x ? -self.dashBackSpeed : self.dashBackSpeed;
			self.x += moveBack;
			// Clamp the hero's x position to the savedX to prevent overshooting
			if (Math.abs(self.x - self.savedX) < Math.abs(moveBack)) {
				self.x = self.savedX;
			}
		}
		// Stop vertical movement while holding down
		if (!self.isHolding) {
			self.y += self.speed * self.gravity;
			var boundaryPadding = 200;
			if (self.y < boundaryPadding) {
				self.y = boundaryPadding;
			}
			if (self.y > game.height - boundaryPadding) {
				self.y = game.height - boundaryPadding;
			}
		}
		// Trigger game over if hero leaves the screen horizontally
		if (self.x < 0 || self.x > game.width) {
			isGameOver = true;
		}
		// Generate particle trail
		if (LK.ticks % 5 == 0) {
			var particle = new Particle();
			particle.x = self.x;
			particle.y = self.y;
			game.addChild(particle);
		}
	};
	self.isHolding = false;
	self.holdStartTime = 0;
	self.startFlashing = function () {
		if (!self.flashInterval) {
			self.flashInterval = LK.setInterval(function () {
				self.visible = !self.visible;
				self.tint = self.visible ? 0xff0000 : 0x00ff00; // Alternate between red and green
			}, 100); // Flash every 100ms
		}
	};
	self.stopFlashing = function () {
		if (self.flashInterval) {
			LK.clearInterval(self.flashInterval);
			self.flashInterval = null;
			self.visible = true; // Ensure hero is visible after stopping flash
			self.tint = 0xffffff; // Reset color to default
		}
	};
	self.onHold = function () {
		if (!self.isHolding) {
			self.isHolding = true;
			self.holdStartTime = LK.ticks;
			self.startFlashing();
			if (self.isDashing) {
				return;
			}
		}
	};
	self.onRelease = function () {
		if (self.isHolding) {
			self.dash();
		}
		self.isHolding = false;
		self.holdStartTime = 0;
		self.stopFlashing();
		if (self.isDashing) {
			return;
		}
	};
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -5;
	self._move_migrated = function () {
		self.x += self.speed;
		if (self.x < -self.width) {
			self.destroy();
		}
	};
});
var Parallax = Container.expand(function () {
	var self = Container.call(this);
	var bgGraphics = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bgGraphics.x = game.width / 2;
	bgGraphics.y = 1500;
	self.speed = -2;
	self._move_migrated = function () {
		bgGraphics.x += self.speed;
		if (bgGraphics.x <= -bgGraphics.width / 2) {
			bgGraphics.x = self.bgGraphics2.x + bgGraphics.width;
		}
		if (!self.bgGraphics2) {
			self.bgGraphics2 = self.attachAsset('background', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.bgGraphics2.x = bgGraphics.x + bgGraphics.width - 1; // Overlap by 1 pixel to prevent visible seams
			self.bgGraphics2.y = 1500;
			self.addChildAt(self.bgGraphics2, 0); // Ensure bgGraphics2 is behind bgGraphics
		} else if (self.bgGraphics2.x <= -self.bgGraphics2.width / 2) {
			self.bgGraphics2.x = bgGraphics.x + bgGraphics.width - 1; // Overlap by 1 pixel to prevent visible seams
		}
		self.bgGraphics2.x += self.speed;
	};
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.alpha = 1.0;
	self.fadeOut = function () {
		self.alpha -= 0.05;
		if (self.alpha <= 0) {
			self.destroy();
		}
	};
});

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

/**** 
* Game Code
****/ 
function startBootSequence() {
	var bootTexts = ['Calibrating Cybernetic Enhancements...', 'Booting Cybernetic Core Systems...', 'All systems ready...'];
	var currentBootTextIndex = 0;
	var bootTextY = game.height / 2 - 100;
	var displayBootText = function displayBootText() {
		var bootText = new BootText(bootTexts[currentBootTextIndex]);
		bootText.x = game.width / 2;
		bootText.y = bootTextY + currentBootTextIndex * 120;
		game.addChild(bootText);
		LK.setInterval(function () {
			bootText.fadeIn();
			if (bootText.alpha === 1) {
				LK.setTimeout(function () {
					bootText.fadeOut();
				}, 300);
			}
		}, 60);
		currentBootTextIndex++;
		if (currentBootTextIndex < bootTexts.length) {
			LK.setTimeout(displayBootText, 1000);
		}
	};
	displayBootText();
}
var hero,
	enemies = [],
	obstacles = [],
	parallax,
	score = 0,
	distanceTraveled = 0,
	isGameOver = false,
	gameStarted = false;
var generateObstacle = function generateObstacle() {
	var obstacle = new Obstacle();
	obstacle.x = game.width;
	obstacle.y = Math.random() * game.height;
	obstacles.push(obstacle);
	game.addChild(obstacle);
};
var obstacleGenerationInterval;
function startObstacleGeneration() {
	obstacleGenerationInterval = LK.setInterval(generateObstacle, 2000);
}
parallax = game.addChild(new Parallax());
var distanceTxt;
function initializeScoreDisplay() {
	// Remove BootText from the screen
	var bootTexts = game.children.filter(function (child) {
		return child instanceof BootText;
	});
	for (var i = 0; i < bootTexts.length; i++) {
		bootTexts[i].destroy();
	}
	// Initialize score display
	distanceTxt = new Text2('Δs: 0', {
		size: 112.5,
		// 150 * 0.75 to reduce by 25%
		fill: "#ffffff"
	});
	distanceTxt.anchor.set(.5, 0);
	LK.gui.top.addChild(distanceTxt);
}
hero = game.addChild(new Hero());
hero.x = -100;
hero.y = -100;
startBootSequence();
LK.on('tick', function () {
	if (!gameStarted) {
		hero.animateToPosition();
		return; // Skip the rest of the game logic until the animation is complete
	}
	parallax._move_migrated();
	hero._move_migrated();
	for (var i = 0; i < enemies.length; i++) {
		enemies[i]._move_migrated();
	}
	for (var i = obstacles.length - 1; i >= 0; i--) {
		obstacles[i]._move_migrated();
		if (!obstacles[i].parent) {
			obstacles.splice(i, 1);
		}
	}
	var particles = game.children.filter(function (child) {
		return child instanceof Particle;
	});
	for (var i = 0; i < particles.length; i++) {
		particles[i].fadeOut();
	}
	if (!isGameOver) {
		distanceTraveled += 1 / 60;
		distanceTxt.setText('Δs: ' + Math.floor(distanceTraveled).toString());
	}
	if (isGameOver) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
	}
});
game.on('down', function (x, y, obj) {
	if (!hero.isDashing) {
		hero.flipGravity();
		hero.onHold();
	}
});
game.on('up', function (x, y, obj) {
	if (!hero.isDashing) {
		hero.onRelease();
	}
});