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

/**** 
* Classes
****/ 
var Beehive = Container.expand(function () {
	var self = Container.call(this);
	// Main hive body - preserve dimensions
	self.hiveBody = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.2,
		scaleY: 1.0,
		tint: 0xD8B373 // More honey-like color for beehive
	});
	// Add honeycomb texture effect with layered shapes - preserve proportions
	for (var i = 0; i < 3; i++) {
		var honeyLayer = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.1 - i * 0.1,
			scaleY: 0.9 - i * 0.1,
			alpha: 0.3,
			tint: 0xFFD700 // Gold honey color
		});
	}
	// Hive entrance - preserve proportions
	self.entrance = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -20,
		scaleX: 0.4,
		scaleY: 0.2,
		tint: 0x8B4513 // Brown color for entrance
	});
	// Darker entrance hole - preserve proportions
	self.entranceHole = self.attachAsset('beeBody', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -20,
		scaleX: 0.2,
		scaleY: 0.15,
		tint: 0x503000 // Dark entrance hole
	});
	// Hive texture stripes - preserve proportions
	for (var i = 0; i < 5; i++) {
		var stripe = self.attachAsset('beeStripe1', {
			anchorX: 0.5,
			anchorY: 0.5,
			y: -25 + i * 15,
			scaleX: 1.1 - Math.abs(i - 2) * 0.1,
			// Curved effect
			scaleY: 0.15
		});
	}
	// Add some honey drips - preserve proportions
	for (var i = 0; i < 3; i++) {
		var honeyDrip = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.0,
			x: -30 + i * 30,
			y: 30,
			scaleX: 0.1,
			scaleY: 0.2 + Math.random() * 0.15,
			tint: 0xFFD700 // Gold honey color
		});
	}
	// Add some bees hovering near the hive - preserve proportions
	for (var i = 0; i < 3; i++) {
		var hoverBee = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25,
			y: -30 - i * 8,
			scaleX: 0.15,
			scaleY: 0.08,
			tint: 0xF7DF18
		});
		// Wings for hovering bees - preserve proportions
		var leftWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25 - 4,
			y: -30 - i * 8 - 4,
			scaleX: 0.1,
			scaleY: 0.04,
			tint: 0xFFFFFF,
			alpha: 0.6
		});
		var rightWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -45 + i * 25 - 4,
			y: -30 - i * 8 + 4,
			scaleX: 0.1,
			scaleY: 0.04,
			tint: 0xFFFFFF,
			alpha: 0.6
		});
		// Animate wings
		tween(leftWing, {
			rotation: -0.8,
			alpha: 0.8
		}, {
			duration: 100 + i * 10,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		tween(rightWing, {
			rotation: 0.8,
			alpha: 0.8
		}, {
			duration: 100 + i * 10,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
	}
	self.bees = [];
	self.lastBeeSpawn = 0;
	// Small breathing animation for the hive
	tween(self, {
		y: self.y - 8
	}, {
		duration: 3000,
		easing: tween.easeInOut,
		repeat: -1,
		yoyo: true
	});
	// Add subtle pulsing effect to the hive
	tween(self.hiveBody, {
		scaleX: self.hiveBody.scaleX * 1.03,
		scaleY: self.hiveBody.scaleY * 1.02
	}, {
		duration: 2000,
		easing: tween.easeInOut,
		repeat: -1,
		yoyo: true
	});
	self.update = function () {
		// Bee spawning has been disabled
		// We keep the update method for future functionality
	};
	self.spawnBee = function () {
		var bee = new Insect('bee', 3);
		bee.x = self.x;
		bee.y = self.y - 80;
		game.addChild(bee);
		insects.push(bee);
		// Make the entrance "pulse" when a bee emerges
		tween(self.entrance, {
			scaleX: self.entrance.scaleX * 1.2,
			scaleY: self.entrance.scaleY * 1.2
		}, {
			duration: 200,
			easing: tween.easeOut,
			complete: function complete() {
				tween(self.entrance, {
					scaleX: 1.0,
					scaleY: 0.6
				}, {
					duration: 300,
					easing: tween.easeIn
				});
			}
		});
		// Setup wing tweens for this new bee
		var wingDuration = 500 + Math.random() * 300;
		tween(bee.leftWing, {
			rotation: -1.2,
			scaleX: bee.leftWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		tween(bee.rightWing, {
			rotation: 1.2,
			scaleX: bee.rightWing.scaleX * 1.2
		}, {
			duration: wingDuration * 0.6,
			easing: tween.easeInOut,
			repeat: -1,
			yoyo: true
		});
		// Play buzz sound
		LK.getSound('buzz').play();
		// Add initial flight pattern as bee leaves hive
		tween(bee, {
			x: bee.x + (Math.random() > 0.5 ? 100 : -100),
			y: bee.y - 100
		}, {
			duration: 800,
			easing: tween.easeOut
		});
	};
	return self;
});
var Insect = Container.expand(function (type, speed) {
	var self = Container.call(this);
	self.type = type || 'bee';
	self.speed = speed || 3;
	self.vx = Math.random() * self.speed * (Math.random() > 0.5 ? 1 : -1);
	self.vy = Math.random() * self.speed * (Math.random() > 0.5 ? 1 : -1);
	self.lastTrailTime = 0;
	self.trailActive = false;
	self.trails = [];
	self.flightOffset = Math.random() * Math.PI * 2; // Random flight pattern offset
	self.flightSpeed = 0.5 + Math.random() * 0.5; // Random flight pattern speed
	self.lastRotation = Math.atan2(self.vy, self.vx);
	self.interactive = true; // Make insect clickable
	if (self.type === 'bee') {
		// Main body
		self.body = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.4,
			scaleY: 0.7
		});
		// Bee head
		self.head = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 80,
			scaleX: 0.6,
			scaleY: 0.6
		});
		// Left wing
		self.leftWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -25,
			y: -30,
			rotation: -0.7,
			scaleX: 0.8,
			alpha: 0.6,
			tint: 0xffffff
		});
		// Right wing
		self.rightWing = self.attachAsset('beeBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -25,
			y: 30,
			rotation: 0.7,
			scaleX: 0.8,
			alpha: 0.6,
			tint: 0xffffff
		});
		// Body stripes (reversed direction - vertical instead of horizontal)
		self.stripe1 = self.attachAsset('beeStripe1', {
			anchorX: 0.5,
			anchorY: 0.5,
			rotation: Math.PI / 2,
			x: -25,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
		self.stripe2 = self.attachAsset('beeStripe2', {
			anchorX: 0.5,
			anchorY: 0.5,
			rotation: Math.PI / 2,
			x: 25,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
	} else {
		// Main body
		self.body = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.6,
			scaleY: 0.6
		});
		// Fly head
		self.head = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 90,
			scaleX: 0.5,
			scaleY: 0.5
		});
		// Left wing
		self.leftWing = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -15,
			y: -25,
			rotation: -0.6,
			scaleX: 1.0,
			scaleY: 0.6,
			alpha: 0.6,
			tint: 0xccccff
		});
		// Right wing
		self.rightWing = self.attachAsset('flyBody', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -15,
			y: 25,
			rotation: 0.6,
			scaleX: 1.0,
			scaleY: 0.6,
			alpha: 0.6,
			tint: 0xccccff
		});
		// Body stripe
		self.stripe1 = self.attachAsset('flyStripe', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.8,
			tint: 0x000000
		});
	}
	self.update = function () {
		// Create more dynamic flight pattern with rapid changes in direction and speed
		var time = LK.ticks * 0.01;
		// Random direction changes based on time
		if (Math.random() < 0.03) {
			// Occasionally make sharp turns
			self.vx += (Math.random() - 0.5) * self.speed * 0.8;
			self.vy += (Math.random() - 0.5) * self.speed * 0.8;
		}
		// Add jerky, insect-like movement with bursts of speed
		var jerkFactor = Math.sin(time * 8) * 0.5; // Higher frequency for more rapid wing beats
		var burstSpeed = Math.random() < 0.01 ? self.speed * 2 : 0; // Occasional speed bursts
		// Normalize velocity for consistent speed
		var currentSpeed = Math.sqrt(self.vx * self.vx + self.vy * self.vy);
		if (currentSpeed > 0) {
			var normalizedVx = self.vx / currentSpeed;
			var normalizedVy = self.vy / currentSpeed;
			// Apply jerk factor and burst speed to create more dynamic movement
			self.x += self.vx + normalizedVx * jerkFactor + normalizedVx * burstSpeed;
			self.y += self.vy + normalizedVy * jerkFactor + normalizedVy * burstSpeed;
		} else {
			// Prevent stalling
			self.vx = (Math.random() - 0.5) * self.speed;
			self.vy = (Math.random() - 0.5) * self.speed;
			self.x += self.vx;
			self.y += self.vy;
		}
		// More energetic bounce off screen edges with slight angle change
		if (self.x < 0 || self.x > 2048) {
			self.vx *= -1.1; // Bounce slightly faster
			// Add slight randomness to bounce angle
			self.vy += (Math.random() - 0.5) * self.speed * 0.5;
			self.x = Math.max(0, Math.min(2048, self.x));
		}
		if (self.y < 0 || self.y > 2732) {
			self.vy *= -1.1; // Bounce slightly faster
			// Add slight randomness to bounce angle
			self.vx += (Math.random() - 0.5) * self.speed * 0.5;
			self.y = Math.max(0, Math.min(2732, self.y));
		}
		// More dynamic rotation with slight overshoot
		var targetRotation = Math.atan2(self.vy, self.vx);
		// Add slight randomness to rotation for more natural movement
		var rotationSpeed = 0.15 + Math.random() * 0.1;
		self.rotation = self.rotation + (targetRotation - self.rotation) * rotationSpeed;
		// Wings are now animated with tweens
		// Just update wing alpha for pulsing effect
		if (self.leftWing && self.rightWing) {
			var wingAlpha = 0.6 + Math.sin(LK.ticks * 0.1) * 0.2;
			self.leftWing.alpha = wingAlpha;
			self.rightWing.alpha = wingAlpha;
		}
		// Create trails when active
		if (self.trailActive && LK.ticks % 5 === 0) {
			var dot = LK.getAsset('trailDot', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0.7,
				tint: 0x000000 // Make all trail dots black
			});
			dot.x = self.x;
			dot.y = self.y;
			if (self.type === 'bee') {
				dot.tint = 0x000000;
			} else {
				dot.tint = 0x000000;
			}
			// Add dot to the game
			game.addChild(dot);
			// Store reference to dot
			self.trails.push({
				dot: dot,
				createdAt: LK.ticks
			});
		}
		// Remove old trail dots after 2 seconds
		for (var i = self.trails.length - 1; i >= 0; i--) {
			var trail = self.trails[i];
			if (LK.ticks - trail.createdAt > 120) {
				trail.dot.destroy();
				self.trails.splice(i, 1);
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var insects = [];
var lastTrailToggleTime = 0;
var trailsEnabled = false;
var timeElapsed = 0;
var currentLevel = 1;
var fliesRemaining = 30;
var fliesCaught = 0;
// Initialize scoreboard to display flies remaining
var scoreTxt = new Text2('Flies: ' + fliesRemaining, {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Level display
var levelTxt = new Text2('Level: ' + currentLevel, {
	size: 60,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0.5, 0);
levelTxt.y = 100;
LK.gui.top.addChild(levelTxt);
// Create beehive at the bottom center
var beehive = new Beehive();
beehive.x = 1024; // Center horizontally
beehive.y = 2732 - 120; // Position right at the bottom, maintain height
game.addChild(beehive);
// Create initial 30 flies
for (var i = 0; i < 30; i++) {
	createInsect();
}
// Set up wing flapping tweens for all insects
function setupWingTweens() {
	for (var i = 0; i < insects.length; i++) {
		var insect = insects[i];
		var wingDuration = 500 + Math.random() * 300; // Random wing flap duration
		// Left wing tween with faster flapping
		tween(insect.leftWing, {
			rotation: -1.2,
			// Wider wing movement
			scaleX: insect.leftWing.scaleX * 1.2 // Wing stretches during flap
		}, {
			duration: wingDuration * 0.6,
			// Faster wing movement
			easing: tween.easeInOut,
			repeat: -1,
			// Continuous flapping
			yoyo: true // Back and forth movement
		});
		// Right wing tween with slight offset
		tween(insect.rightWing, {
			rotation: 1.2,
			// Wider wing movement
			scaleX: insect.rightWing.scaleX * 1.2 // Wing stretches during flap
		}, {
			duration: wingDuration * 0.6,
			// Faster wing movement
			easing: tween.easeInOut,
			repeat: -1,
			// Continuous flapping
			yoyo: true // Back and forth movement
		});
	}
}
// Initialize wing tweens
setupWingTweens();
// Play background music
LK.playMusic('bgmusic');
// Game timer
var gameTimer = LK.setInterval(function () {
	timeElapsed += 1;
	// Toggle trails every 10 seconds
	if (timeElapsed % 10 === 0 && timeElapsed > 0) {
		toggleTrails();
	}
	// Don't automatically create new insects as they're now part of the level system
}, 1000);
// Function to handle level completion
function levelComplete() {
	// Increase level
	currentLevel++;
	levelTxt.setText('Level: ' + currentLevel);
	// Reset flies for next level
	fliesRemaining = 30;
	fliesCaught = 0;
	scoreTxt.setText('Flies: ' + fliesRemaining);
	// Flash screen to indicate level complete
	LK.effects.flashScreen(0xFFFFFF, 500, 0.5);
	// Remove any remaining insects
	for (var i = insects.length - 1; i >= 0; i--) {
		insects[i].destroy();
	}
	insects = [];
	// Create new flies for the next level
	LK.setTimeout(function () {
		for (var i = 0; i < 30; i++) {
			createInsect();
		}
	}, 1000);
}
// Function to create a new insect
function createInsect() {
	var type = 'fly'; // Only create flies
	var speed = 2 + Math.random() * 3; // Random speed between 2-5
	var insect = new Insect(type, speed);
	// Position randomly
	insect.x = Math.random() * 2048;
	insect.y = Math.random() * 2000; // Keep away from bottom
	game.addChild(insect);
	insects.push(insect);
	// Setup smooth wing tweens for this insect
	var wingDuration = 500 + Math.random() * 300; // Random wing flap duration
	// Left wing tween with faster flapping
	tween(insect.leftWing, {
		rotation: -1.2,
		// Wider wing movement
		scaleX: insect.leftWing.scaleX * 1.2 // Wing stretches during flap
	}, {
		duration: wingDuration * 0.6,
		// Faster wing movement
		easing: tween.easeInOut,
		repeat: -1,
		// Continuous flapping
		yoyo: true // Back and forth movement
	});
	// Right wing tween with slight offset
	tween(insect.rightWing, {
		rotation: 1.2,
		// Wider wing movement
		scaleX: insect.rightWing.scaleX * 1.2 // Wing stretches during flap
	}, {
		duration: wingDuration * 0.6,
		// Faster wing movement
		easing: tween.easeInOut,
		repeat: -1,
		// Continuous flapping
		yoyo: true // Back and forth movement
	});
	// Add more dynamic body movement
	var bodyBobDuration = 400 + Math.random() * 300; // Faster body movement
	tween(insect, {
		y: insect.y + (Math.random() * 30 - 15),
		// Random up/down movement
		x: insect.x + (Math.random() * 30 - 15),
		// Random left/right movement
		rotation: insect.rotation + (Math.random() * 0.2 - 0.1) // Slight random rotation
	}, {
		duration: bodyBobDuration,
		easing: tween.easeInOut,
		repeat: -1,
		// Infinite repetition
		yoyo: true // Ping-pong effect
	});
	// Make insect clickable
	insect.down = function (x, y, obj) {
		// Remove the fly when clicked
		insect.destroy();
		// Remove from insects array
		var index = insects.indexOf(insect);
		if (index > -1) {
			insects.splice(index, 1);
		}
		// Update score
		fliesCaught++;
		fliesRemaining--;
		scoreTxt.setText('Flies: ' + fliesRemaining);
		// Play buzz sound
		LK.getSound('buzz').play();
		// Check if level is complete
		if (fliesRemaining <= 0) {
			levelComplete();
		}
	};
	// Play buzz sound on creation
	LK.getSound('buzz').play();
}
// Function to toggle trails on all insects
function toggleTrails() {
	trailsEnabled = !trailsEnabled;
	for (var i = 0; i < insects.length; i++) {
		insects[i].trailActive = trailsEnabled;
	}
	if (trailsEnabled) {
		// Flash screen slightly to indicate trails activated
		LK.effects.flashScreen(0xFFFFFF, 300, 0.3);
	}
}
// Helper function to calculate distance between two points
function getDistance(x1, y1, x2, y2) {
	var dx = x2 - x1;
	var dy = y2 - y1;
	return Math.sqrt(dx * dx + dy * dy);
}
// Touch/mouse handlers removed as player is gone
// Main game update function
game.update = function () {
	// Update beehive
	beehive.update();
	// Add slight random movement to insects occasionally
	if (LK.ticks % 60 === 0) {
		for (var i = 0; i < insects.length; i++) {
			var insect = insects[i];
			// Change velocity slightly
			insect.vx += (Math.random() - 0.5) * 2;
			insect.vy += (Math.random() - 0.5) * 2;
			// Limit max speed
			var speed = Math.sqrt(insect.vx * insect.vx + insect.vy * insect.vy);
			if (speed > insect.speed) {
				insect.vx = insect.vx / speed * insect.speed;
				insect.vy = insect.vy / speed * insect.speed;
			}
		}
	}
};