/**** 
* Classes
****/ 
// Obstacle class
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	//self.angleSpeed = 0.01;
	self.orbitSpeed = -0.01;
	self.move = function () {
		// Obstacle move logic
		//var angleSpeed = -0.01 * self.parent.direction; //self.orbitSpeed;
		//self.radius = self.parent.width / 2 - self.width / 2;
		self.radius = self.parent.width / 2 * (1900 / self.parent.width) - self.width / 2 * (100 / self.width);
		self.angle = (self.angle || 0) + self.orbitSpeed;
		self.angle %= Math.PI * 2;
		self.x = self.radius * Math.cos(self.angle);
		self.y = self.radius * Math.sin(self.angle);
	};
});
// Orbit class
var Orbit = Container.expand(function () {
	var self = Container.call(this);
	var orbitGraphics = self.attachAsset('orbit1', {
		anchorX: 0.5,
		anchorY: 0.5,
		//tint: Math.floor(Math.random() * 16777215)
		tint: rainbowColors[orbitsCreated % rainbowColors.length]
	});
	orbitsCreated++;
	orbitGraphics.alpha = 0.5;
	self.direction = Math.random() < 0.5 ? 1 : -1;
	self.positionOrbit = function (i) {
		self.x = 2048 / 2;
		self.y = 2732 / 2;
		this.width = 1900 - i * 500;
		this.height = 1900 - i * 500;
		if (i !== 0) {
			this.numBarriers = 1 + Math.floor(Math.random() * (i + currentOrbitIndex));
			if (this.numBarriers > 12) {
				this.numBarriers = 12;
			}
			// Add powerup to some orbits
			if (orbitsCreated % 17 == 0) {
				this.numBarriers = 0;
				self.addPowerup(0);
				//orbitGraphics.tint %= 0x222222;
				self.addPowerup(1);
				self.addPowerup(2);
				self.addPowerup(3);
				self.addPowerup(4);
			}
			//self.barrierSpeed = Math.random() * currentOrbitIndex + 1 / 20;
			self.barrierSpeed = 0.01 + Math.random() * 0.015 * self.direction;
			for (var j = 0; j < this.numBarriers; j++) {
				self.addBarrier(self.barrierSpeed, j);
				//console.log('adding barrier: ', j);
			}
		}
	};
	var orbitGraphicsMask = self.attachAsset('blackSphere', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
		//tint: rainbowColors[(orbitsCreated + 1) % rainbowColors.length]
	});
	//orbitGraphicsMask.alpha = 0.1;
	orbitGraphicsMask.width = self.width - 200;
	orbitGraphicsMask.height = self.height - 200;
	self.addBarrier = function (speed, index) {
		var barrier = new Obstacle();
		barrier.orbitSpeed = speed;
		//barrier.angle = index * (Math.PI * 2 / 20);
		barrier.angle = Math.random() * (Math.PI * 2);
		/* 
		barrier.move = function () {
		barrier.angle += barrier.orbitSpeed * (self.direction === 1 ? 1 : -1);
		barrier.x = self.x + (self.width - barrier.width) / 2 * Math.cos(barrier.angle);
		barrier.y = self.y + (self.height - barrier.height) / 2 * Math.sin(barrier.angle);
		};*/
		self.addChild(barrier);
		obstacles.push(barrier);
	};
	self.addPowerup = function (index) {
		var powerup = new Powerup1();
		powerup.angle = Math.PI * 1.5 - index * 0.1;
		powerup.scale.x = 1 - index * 0.2;
		powerup.scale.y = 1 - index * 0.2;
		self.addChild(powerup);
		obstacles.push(powerup);
	};
});
/**** 
TODO:
* Maybe player should change orbit direction (and/or speed) with the orbit he jumps into?
* Make sure orbits don't have too many obstacles.
* Maybe skip player and obstacle updating while scaling?
* Current min and max speeds of obstacles should be closer to each other.
* Maybe background should tint with an offset on the colorwheel?
* Rotate orbits with obstacles statically distributed on them instead of calculating obstacle positions (for performance).
* Would also be cool to be able to jump in AND out of orbits, but hard to implement. Or maybe just tap on the orbit to go to?
****/ 
// Player class
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = 900;
	self.angle = 0;
	self.jump = function () {
		currentOrbitIndex++;
		var targetOrbit = orbits[currentOrbitIndex];
		self.angle = Math.atan2(self.y - 2732 / 2, self.x - 2048 / 2);
		if (targetOrbit) {
			//self.radius = (targetOrbit.width - 100) / 2;
			self.radius = targetOrbit.width / 2;
			//console.log('self.radius after setting it to targetOrbits: ' + self.radius);
		} else {
			self.radius = 0; // Fallback radius if targetOrbit is not defined
		}
		self.x = 2048 / 2 + self.radius * Math.cos(self.angle);
		self.y = 2732 / 2 + self.radius * Math.sin(self.angle);
		//self.scale.x = 0.70;
		//self.scale.y = 0.70;
		self.width = 70;
		self.height = self.width;
		scaling = true;
		LK.setScore(LK.getScore() + 1);
		scoreTxt.setText(LK.getScore());
		/* 
		var orbit = game.addChild(new Orbit());
		orbit.positionOrbit(4);
		orbits.push(orbit);
		// Move player to the topmost z-index
		game.setChildIndex(player, game.children.length - 1);
		*/ 
	};
	self.update = function () {
		var centerX = 2048 / 2;
		var centerY = 2732 / 2;
		self.angleSpeed = 0.01;
		self.angle = (self.angle || 0) + self.angleSpeed;
		self.x = centerX + self.radius * Math.cos(self.angle);
		self.y = centerY + self.radius * Math.sin(self.angle);
	};
});
// Powerup class
var Powerup1 = Container.expand(function () {
	var self = Container.call(this);
	var powerup1Graphics = self.attachAsset('powerup2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	//self.angleSpeed = 0.01;
	//self.orbitSpeed = 0.075;
	self.orbitSpeed = 0.035;
	self.move = function () {
		self.radius = self.parent.width / 2 * (1900 / self.parent.width) - self.width / 2 * (100 / self.width) + 10;
		self.angle = (self.angle || 0) + self.orbitSpeed;
		self.x = self.radius * Math.cos(self.angle);
		self.y = self.radius * Math.sin(self.angle);
	};
});

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

/**** 
* Game Code
****/ 
function hsvToHex(h, s, v) {
	var r, g, b, i, f, p, q, t;
	i = Math.floor(h * 6);
	f = h * 6 - i;
	p = v * (1 - s);
	q = v * (1 - f * s);
	t = v * (1 - (1 - f) * s);
	switch (i % 6) {
		case 0:
			r = v, g = t, b = p;
			break;
		case 1:
			r = q, g = v, b = p;
			break;
		case 2:
			r = p, g = v, b = t;
			break;
		case 3:
			r = p, g = q, b = v;
			break;
		case 4:
			r = t, g = p, b = v;
			break;
		case 5:
			r = v, g = p, b = q;
			break;
	}
	var toHex = function toHex(x) {
		var hex = Math.round(x * 255).toString(16);
		return hex.length === 1 ? '0' + hex : hex;
	};
	return '0x' + toHex(r) + toHex(g) + toHex(b);
}
//console.log(rainbowColors);
// A for our purposes optimized hitdetection, based on orbit layer and angle.
var radIntersects = function radIntersects(p, t) {
	if (t.parent == orbits[currentOrbitIndex]) {
		var pa = (p.angle * (180 / Math.PI) + 180) % 360;
		var ta = (t.angle * (180 / Math.PI) + 180) % 360;
		if (Math.abs(pa - ta) < 6) {
			return true;
		} else {
			return false;
		}
	} else {
		return false;
	}
};
var powerupText;
var showPowerupText = function showPowerupText() {
	powerupText = new Text2('Powerup Activated!\nAll visible obstacles cleared!\nTap to continue', {
		size: 100,
		fill: "#bbbbbb",
		align: 'center'
	});
	powerupText.y = 2700 / 2;
	powerupText.x = 2048 / 2;
	powerupText.anchor.set(0.5, 0.5);
	//instructionText.x = 2048 / 2; // Center horizontally
	//instructionText.y = 2732 - instructionText.height / 2; // Position at the bottom
	game.addChild(powerupText);
	LK.setTimeout(function () {
		var fadeDuration = 3000;
		var fadeStep = 30;
		var fadeInterval = fadeDuration / fadeStep;
		var currentStep = 0;
		var fadeOutInterval = LK.setInterval(function () {
			if (powerupText) {
				powerupText.alpha -= 1 / fadeStep;
			}
			currentStep++;
			if (currentStep >= fadeStep) {
				LK.clearInterval(fadeOutInterval);
				game.removeChild(powerupText);
				powerupText = null;
			}
		}, fadeInterval);
	}, 0);
};
// Initialize assets used in this game.
// Game variables
var player;
var orbits = [];
var obstacles = [];
var currentOrbitIndex = 0;
var scaling = false;
var scalingCounter = 0;
var scalingSpeed = 50;
var scalingTarget = 500;
var numColors = 18;
var orbitsCreated = Math.floor(Math.random() * numColors);
var rainbowColors = function () {
	var colors = [];
	for (var i = 0; i < numColors; i++) {
		var hue = i * (360 / numColors) % 360;
		colors.push(hsvToHex(hue / 360, 1, 1));
	}
	return colors;
}();
var powerup1Activated = false;
// Initialize player
var scoreTxt = new Text2('0', {
	size: 150,
	fill: "#ffffff"
});
LK.gui.top.addChild(scoreTxt);
// Initialize orbits
function createOrbits() {
	for (var i = 0; i < 5; i++) {
		var orbit = game.addChild(new Orbit());
		orbit.positionOrbit(i);
		orbits.push(orbit);
	}
}
createOrbits();
// Add instruction text at the bottom of the screen
var instructionText = new Text2('Tap to jump to the next orbit.\nDon\'t hit the red obstacles.', {
	size: 50,
	fill: "#bbbbbb",
	align: 'center'
});
instructionText.y = 163;
instructionText.x = 50;
instructionText.anchor.set(0.5, 0);
//instructionText.x = 2048 / 2; // Center horizontally
//instructionText.y = 2732 - instructionText.height / 2; // Position at the bottom
LK.gui.top.addChild(instructionText);
//game.setBackgroundColor(rainbowColors[7] + 0xdddddd);
player = game.addChild(new Player());
//player.x = 2048 / 2;
//player.y = 2732 / 2 - 200; // Start the player 200px above the center
/* 
console.log('Player radius is now: ' + player.radius);
console.log('Orbits.length is now: ' + orbits.length);
console.log('CurrentOrbitIndex is now: ' + currentOrbitIndex);
console.log('width of currentorbit is now: ' + orbits[currentOrbitIndex].width);
*/ 
// Game logic
game.on('down', function (obj) {
	if (powerupText) {
		game.removeChild(powerupText);
		powerupText = null;
	}
	if (!scaling) {
		player.jump(currentOrbitIndex);
		LK.gui.top.removeChild(instructionText);
	}
});
LK.on('tick', function () {
	player.update();
	if (powerup1Activated) {
		powerup1Activated = false;
		for (var i = obstacles.length - 1; i > 0; i--) {
			obstacles[i].destroy();
			obstacles[i]._destroyed = true;
		}
	}
	if (scaling) {
		scalingCounter++;
		for (var i = 0; i < orbits.length; i++) {
			orbits[i].width += scalingSpeed;
			orbits[i].height += scalingSpeed;
			//player.radius += scalingSpeed * 0.1;
		}
		player.radius = orbits[currentOrbitIndex].width / 2 - 50;
		if (player.width < 100) {
			player.width += 0.3;
			player.height = player.width;
		}
		//player.scale.x = player.scale.y =
		if (scalingCounter == scalingTarget / scalingSpeed) {
			scaling = false;
			scalingCounter = 0;
			var orbit = game.addChild(new Orbit());
			orbit.positionOrbit(4);
			orbits.push(orbit);
			game.setChildIndex(player, game.children.length - 1);
			player.width = 100;
			player.height = 100;
			//game.setBackgroundColor(rainbowColors[(10 + currentOrbitIndex) % 15] + 0xdddddd);
			/* 
			console.log('Player radius is now: ' + player.radius);
			console.log('Orbits.length is now: ' + orbits.length);
			console.log('CurrentOrbitIndex is now: ' + currentOrbitIndex);
			console.log('width of currentorbit is now: ' + orbits[currentOrbitIndex].width);
			*/ 
		}
	}
	// Update orbits
	for (var i = orbits.length - 1; i > 0; i--) {
		//orbits[i].positionOrbit(i);
		var orb = orbits[i];
		//if (orb && orb.width > 2700) {
		if (orb && orb.width > 3500) {
			for (var j = 0; j < orb.children.length; j++) {
				var child = orb.children[j];
				if (child instanceof Obstacle || child instanceof Powerup1) {
					// child is an instance of YourClass, do something with it
					child._destroyed = true;
				}
			}
			orbits[i].destroy();
			// Splice alters jump logic, so alter currentTargetOrbit too.
			orbits.splice(i, 1);
			currentOrbitIndex--;
		}
	}
	// Update obstacles
	for (var i = obstacles.length - 1; i > 0; i--) {
		if (obstacles[i] && !obstacles[i]._destroyed) {
			obstacles[i].move();
			//if (player.intersects(obstacles[i])) {
			if (radIntersects(player, obstacles[i])) {
				var t = obstacles[i];
				//console.log('collision occurred: (obstacle:', t.radius, t.angle % (Math.PI * 2), ') , (player: ', player.radius, player.angle % (Math.PI * 2));
				var ta = (t.angle * (180 / Math.PI) + 180) % 360;
				var pa = (player.angle * (180 / Math.PI) + 180) % 360;
				//console.log(ta, pa);
				//if (radIntersects(player, obstacles[i], 100)) {
				if (obstacles[i] instanceof Powerup1) {
					obstacles[i].destroy();
					obstacles[i]._destroyed = true;
					if (!powerup1Activated) {
						LK.effects.flashScreen(0xffffff, 1000);
						//LK.effects.flashScreen(rainbowColors[Math.floor(Math.random() * numColors)], 1000);
						powerup1Activated = true;
						showPowerupText();
					}
				} else {
					LK.effects.flashScreen(0xff0000, 1000);
					LK.showGameOver();
				}
			}
		} else {
			obstacles.splice(i, 1);
			//console.log('obstacles.length is now: ' + obstacles.length);
		}
	}
});