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

/**** 
* Classes
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	// Card properties
	self.cardData = cardData || {
		name: "Basic Card",
		cost: 1,
		attack: 2,
		health: 2,
		description: "A basic creature card"
	};
	self.maxHealth = self.cardData.health;
	self.currentHealth = self.cardData.health;
	self.isPlayable = false;
	self.isOnBattlefield = false;
	self.hasAttacked = false;
	// Create card graphics
	var cardBg = self.attachAsset('cardFront', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Card text elements
	var nameText = new Text2(self.cardData.name, {
		size: 24,
		fill: 0x2C3E50
	});
	nameText.anchor.set(0.5, 0);
	nameText.x = 0;
	nameText.y = -100;
	self.addChild(nameText);
	var costText = new Text2(self.cardData.cost.toString(), {
		size: 32,
		fill: 0x9B59B6
	});
	costText.anchor.set(0.5, 0.5);
	costText.x = -70;
	costText.y = -100;
	self.addChild(costText);
	var attackText = new Text2(self.cardData.attack.toString(), {
		size: 28,
		fill: 0xE74C3C
	});
	attackText.anchor.set(0.5, 0.5);
	attackText.x = -50;
	attackText.y = 90;
	self.addChild(attackText);
	var healthText = new Text2(self.currentHealth.toString(), {
		size: 28,
		fill: 0x27AE60
	});
	healthText.anchor.set(0.5, 0.5);
	healthText.x = 50;
	healthText.y = 90;
	self.addChild(healthText);
	self.updateHealthDisplay = function () {
		healthText.setText(self.currentHealth.toString());
		if (self.currentHealth <= 0) {
			cardBg.alpha = 0.5;
		}
	};
	self.takeDamage = function (damage) {
		self.currentHealth -= damage;
		if (self.currentHealth < 0) self.currentHealth = 0;
		self.updateHealthDisplay();
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 500);
	};
	self.canAttack = function () {
		return self.isOnBattlefield && !self.hasAttacked && self.currentHealth > 0;
	};
	self.attack = function (target) {
		if (self.canAttack() && target) {
			// Check if both cards are in the same lane
			if (self.laneIndex !== undefined && target.laneIndex !== undefined && self.laneIndex !== target.laneIndex) {
				return; // Cannot attack cards in different lanes
			}
			// Store original position
			var originalX = self.x;
			var originalY = self.y;
			// Calculate target position (move towards target)
			var targetX = target.x;
			var targetY = target.y;
			// Animate attack: move toward target, then back
			tween(self, {
				x: targetX,
				y: targetY
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Collision animation - both cards shake and flash on impact
					var collisionDuration = 150;
					// Shake the attacking card
					tween(self, {
						x: targetX + 20
					}, {
						duration: collisionDuration / 3,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							tween(self, {
								x: targetX - 20
							}, {
								duration: collisionDuration / 3,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									tween(self, {
										x: targetX
									}, {
										duration: collisionDuration / 3,
										easing: tween.easeInOut
									});
								}
							});
						}
					});
					// Shake the target card
					tween(target, {
						x: target.x - 15
					}, {
						duration: collisionDuration / 3,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							tween(target, {
								x: target.x + 15
							}, {
								duration: collisionDuration / 3,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									tween(target, {
										x: target.x
									}, {
										duration: collisionDuration / 3,
										easing: tween.easeInOut
									});
								}
							});
						}
					});
					// Flash both cards white for collision effect
					tween(self, {
						tint: 0xFFFFFF
					}, {
						duration: collisionDuration,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							tween(self, {
								tint: 0xFFFFFF
							}, {
								duration: collisionDuration,
								easing: tween.easeInOut
							});
						}
					});
					tween(target, {
						tint: 0xFFFFFF
					}, {
						duration: collisionDuration,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							tween(target, {
								tint: 0xFFFFFF
							}, {
								duration: collisionDuration,
								easing: tween.easeInOut
							});
						}
					});
					// Deal damage when collision happens
					target.takeDamage(self.cardData.attack);
					// After collision, animate return to original position
					LK.setTimeout(function () {
						tween(self, {
							x: originalX,
							y: originalY
						}, {
							duration: 300,
							easing: tween.easeIn
						});
					}, collisionDuration);
				}
			});
			self.hasAttacked = true;
			cardBg.alpha = 0.7;
			LK.getSound('attack').play();
		}
	};
	self.resetForNewTurn = function () {
		self.hasAttacked = false;
		if (self.currentHealth > 0) {
			cardBg.alpha = 1.0;
		}
	};
	return self;
});
var Player = Container.expand(function (isHuman) {
	var self = Container.call(this);
	self.isHuman = isHuman || false;
	self.health = 30;
	self.maxMana = 3;
	self.currentMana = 3;
	self.hand = [];
	self.battlefield = [];
	self.deck = [];
	// Initialize deck with basic cards
	var cardTypes = [{
		name: "Fire Imp",
		cost: 1,
		attack: 2,
		health: 1,
		description: "A small fire creature"
	}, {
		name: "Water Spirit",
		cost: 2,
		attack: 2,
		health: 3,
		description: "A defensive water creature"
	}, {
		name: "Earth Golem",
		cost: 3,
		attack: 4,
		health: 3,
		description: "A powerful earth creature"
	}, {
		name: "Air Wisp",
		cost: 1,
		attack: 1,
		health: 2,
		description: "A quick air creature"
	}, {
		name: "Lightning Bolt",
		cost: 2,
		attack: 3,
		health: 1,
		description: "A shocking creature"
	}, {
		name: "Walter Spirit",
		cost: 2,
		attack: 2,
		health: 4,
		description: "A mystical water spirit with high endurance"
	}];
	for (var i = 0; i < 20; i++) {
		var randomCard = cardTypes[Math.floor(Math.random() * cardTypes.length)];
		self.deck.push(new Card(randomCard));
	}
	self.drawCard = function () {
		if (self.deck.length > 0 && self.hand.length < 7) {
			var card = self.deck.pop();
			self.hand.push(card);
			LK.getSound('cardDraw').play();
			return card;
		}
		return null;
	};
	self.canPlayCard = function (card) {
		return card && card.cardData.cost <= self.currentMana;
	};
	self.playCard = function (card) {
		var handIndex = self.hand.indexOf(card);
		if (handIndex >= 0 && self.canPlayCard(card) && self.battlefield.length < 3) {
			self.hand.splice(handIndex, 1);
			self.battlefield.push(card);
			self.currentMana -= card.cardData.cost;
			card.isOnBattlefield = true;
			LK.getSound('cardPlay').play();
			return true;
		}
		return false;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) self.health = 0;
	};
	self.startTurn = function () {
		self.currentMana = Math.min(self.maxMana, self.currentMana + 1);
		if (self.maxMana < 10) self.maxMana++;
		// Reset battlefield cards
		for (var i = 0; i < self.battlefield.length; i++) {
			self.battlefield[i].resetForNewTurn();
		}
		// Draw a card
		self.drawCard();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentPlayer = 0; // 0 = human, 1 = AI
var gamePhase = "playing"; // "playing", "gameOver"
var selectedCard = null;
var draggedCard = null;
// Create players
var humanPlayer = new Player(true);
var aiPlayer = new Player(false);
var players = [humanPlayer, aiPlayer];
// Create game areas
var opponentAreaBg = game.addChild(LK.getAsset('opponentArea', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 200,
	alpha: 0.3
}));
var battlefieldBg = game.addChild(LK.getAsset('battlefield', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 1000,
	alpha: 0.3
}));
var playerAreaBg = game.addChild(LK.getAsset('playerArea', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 1800,
	alpha: 0.3
}));
// Create visible lane graphics
var lanePositions = [600, 1024, 1448]; // Left, Center, Right lanes - centered
var lanes = [];
// Create lanes with borders for visual clarity
for (var i = 0; i < 3; i++) {
	// Lane border (darker background)
	var laneBorder = game.addChild(LK.getAsset('laneBorder', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: lanePositions[i],
		y: 1366,
		alpha: 0.4
	}));
	// Lane background (lighter)
	var lane = game.addChild(LK.getAsset('lane', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: lanePositions[i],
		y: 1366,
		alpha: 0.3
	}));
	lanes.push({
		border: laneBorder,
		background: lane
	});
	// Add lane number text
	var laneText = new Text2("Lane " + (i + 1), {
		size: 24,
		fill: 0xECF0F1
	});
	laneText.anchor.set(0.5, 0.5);
	laneText.x = lanePositions[i];
	laneText.y = 1636;
	laneText.alpha = 0.6;
	game.addChild(laneText);
}
// UI Elements
var playerHealthText = new Text2("Health: 30", {
	size: 48,
	fill: 0xECF0F1
});
playerHealthText.anchor.set(0, 0.5);
playerHealthText.x = 50;
playerHealthText.y = 1950;
game.addChild(playerHealthText);
var opponentHealthText = new Text2("Enemy: 30", {
	size: 48,
	fill: 0xECF0F1
});
opponentHealthText.anchor.set(0, 0.5);
opponentHealthText.x = 50;
opponentHealthText.y = 350;
game.addChild(opponentHealthText);
var manaText = new Text2("Mana: 3/3", {
	size: 36,
	fill: 0x9B59B6
});
manaText.anchor.set(0, 0.5);
manaText.x = 50;
manaText.y = 2000;
game.addChild(manaText);
var turnText = new Text2("Your Turn", {
	size: 42,
	fill: 0xF39C12
});
turnText.anchor.set(0.5, 0.5);
turnText.x = 1024;
turnText.y = 100;
game.addChild(turnText);
// End turn button
var endTurnBtn = game.addChild(LK.getAsset('endTurnButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1800,
	y: 1950
}));
var endTurnText = new Text2("End Turn", {
	size: 28,
	fill: 0x2C3E50
});
endTurnText.anchor.set(0.5, 0.5);
endTurnText.x = 1800;
endTurnText.y = 1950;
game.addChild(endTurnText);
// Initialize starting hands
for (var i = 0; i < 4; i++) {
	humanPlayer.drawCard();
	aiPlayer.drawCard();
}
function updateUI() {
	playerHealthText.setText("Health: " + humanPlayer.health);
	opponentHealthText.setText("Enemy: " + aiPlayer.health);
	manaText.setText("Mana: " + humanPlayer.currentMana + "/" + humanPlayer.maxMana);
	if (currentPlayer === 0) {
		turnText.setText("Your Turn");
		turnText.fill = "#f39c12";
	} else {
		turnText.setText("Enemy Turn");
		turnText.fill = "#e74c3c";
	}
}
function arrangeHand() {
	var handCards = humanPlayer.hand;
	var startX = 1024 - handCards.length * 100;
	for (var i = 0; i < handCards.length; i++) {
		var card = handCards[i];
		if (!game.children.includes(card)) {
			game.addChild(card);
		}
		card.x = startX + i * 200;
		card.y = 2300;
		card.isPlayable = humanPlayer.canPlayCard(card);
		// Visual feedback for playable cards
		if (card.isPlayable && currentPlayer === 0) {
			card.alpha = 1.0;
		} else {
			card.alpha = 0.6;
		}
	}
}
function arrangeBattlefield() {
	// Define 3 lane positions
	var lanePositions = [600, 1024, 1448]; // Left, Center, Right lanes - centered
	// Player battlefield
	var playerCards = humanPlayer.battlefield;
	for (var i = 0; i < playerCards.length && i < 3; i++) {
		var card = playerCards[i];
		if (!game.children.includes(card)) {
			game.addChild(card);
		}
		card.x = lanePositions[i];
		card.y = 1516;
		card.laneIndex = i;
	}
	// AI battlefield
	var aiCards = aiPlayer.battlefield;
	for (var i = 0; i < aiCards.length && i < 3; i++) {
		var card = aiCards[i];
		if (!game.children.includes(card)) {
			game.addChild(card);
		}
		card.x = lanePositions[i];
		card.y = 1216;
		card.laneIndex = i;
	}
}
function checkGameOver() {
	if (humanPlayer.health <= 0) {
		gamePhase = "gameOver";
		LK.showGameOver();
		return true;
	} else if (aiPlayer.health <= 0) {
		gamePhase = "gameOver";
		LK.showYouWin();
		return true;
	}
	return false;
}
function endTurn() {
	currentPlayer = 1 - currentPlayer;
	players[currentPlayer].startTurn();
	if (currentPlayer === 1) {
		// AI turn
		LK.setTimeout(function () {
			performAITurn();
		}, 1000);
	}
	updateUI();
	arrangeHand();
	arrangeBattlefield();
}
function performAITurn() {
	// Simple AI: play random playable card if battlefield has space
	var playableCards = aiPlayer.hand.filter(function (card) {
		return aiPlayer.canPlayCard(card);
	});
	if (playableCards.length > 0 && aiPlayer.battlefield.length < 3) {
		var randomCard = playableCards[Math.floor(Math.random() * playableCards.length)];
		// Find available lane for AI
		var availableLanes = [0, 1, 2];
		for (var i = 0; i < aiPlayer.battlefield.length; i++) {
			var occupiedLane = aiPlayer.battlefield[i].laneIndex;
			if (occupiedLane !== undefined) {
				var laneIdx = availableLanes.indexOf(occupiedLane);
				if (laneIdx >= 0) availableLanes.splice(laneIdx, 1);
			}
		}
		if (availableLanes.length > 0 && aiPlayer.playCard(randomCard)) {
			randomCard.targetLane = availableLanes[Math.floor(Math.random() * availableLanes.length)];
		}
	}
	// AI attacks with random creature
	var attackers = aiPlayer.battlefield.filter(function (card) {
		return card.canAttack();
	});
	if (attackers.length > 0) {
		var attacker = attackers[Math.floor(Math.random() * attackers.length)];
		// Target player directly if no defenders
		if (humanPlayer.battlefield.length === 0) {
			// Store original position for animation
			var originalX = attacker.x;
			var originalY = attacker.y;
			// Animate attack toward player area
			tween(attacker, {
				x: 1024,
				y: 2000
			}, {
				duration: 400,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Deal damage when reaching player area
					humanPlayer.takeDamage(attacker.cardData.attack);
					// Animate return to original position
					tween(attacker, {
						x: originalX,
						y: originalY
					}, {
						duration: 400,
						easing: tween.easeIn
					});
				}
			});
			attacker.hasAttacked = true;
		} else {
			// Attack player creature in the same lane only
			var defenders = humanPlayer.battlefield.filter(function (card) {
				return card.currentHealth > 0 && card.laneIndex === attacker.laneIndex;
			});
			if (defenders.length > 0) {
				var target = defenders[Math.floor(Math.random() * defenders.length)];
				attacker.attack(target);
			} else {
				// If no defender in same lane, attack player directly
				var originalX = attacker.x;
				var originalY = attacker.y;
				tween(attacker, {
					x: 1024,
					y: 2000
				}, {
					duration: 400,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						humanPlayer.takeDamage(attacker.cardData.attack);
						tween(attacker, {
							x: originalX,
							y: originalY
						}, {
							duration: 400,
							easing: tween.easeIn
						});
					}
				});
				attacker.hasAttacked = true;
			}
		}
	}
	// Remove dead cards
	for (var i = humanPlayer.battlefield.length - 1; i >= 0; i--) {
		if (humanPlayer.battlefield[i].currentHealth <= 0) {
			var deadCard = humanPlayer.battlefield[i];
			game.removeChild(deadCard);
			humanPlayer.battlefield.splice(i, 1);
		}
	}
	// End AI turn
	LK.setTimeout(function () {
		if (!checkGameOver()) {
			endTurn();
		}
	}, 1500);
}
// Event handlers
game.down = function (x, y, obj) {
	if (gamePhase !== "playing" || currentPlayer !== 0) return;
	// Check if end turn button was clicked
	if (x >= 1700 && x <= 1900 && y >= 1910 && y <= 1990) {
		endTurn();
		return;
	}
	// Check if a hand card was clicked
	for (var i = 0; i < humanPlayer.hand.length; i++) {
		var card = humanPlayer.hand[i];
		var cardBounds = {
			left: card.x - 90,
			right: card.x + 90,
			top: card.y - 125,
			bottom: card.y + 125
		};
		if (x >= cardBounds.left && x <= cardBounds.right && y >= cardBounds.top && y <= cardBounds.bottom) {
			if (card.isPlayable) {
				selectedCard = card;
				draggedCard = card;
			}
			return;
		}
	}
	// Check if battlefield card was clicked for attacking
	for (var i = 0; i < humanPlayer.battlefield.length; i++) {
		var card = humanPlayer.battlefield[i];
		var cardBounds = {
			left: card.x - 90,
			right: card.x + 90,
			top: card.y - 125,
			bottom: card.y + 125
		};
		if (x >= cardBounds.left && x <= cardBounds.right && y >= cardBounds.top && y <= cardBounds.bottom) {
			if (card.canAttack()) {
				selectedCard = card;
			}
			return;
		}
	}
};
game.move = function (x, y, obj) {
	if (draggedCard) {
		draggedCard.x = x;
		draggedCard.y = y;
	}
};
game.up = function (x, y, obj) {
	if (draggedCard && y < 1716 && y > 1116) {
		// Determine which lane the card was dropped in
		var targetLane = -1;
		if (x >= 380 && x < 812) targetLane = 0; // Left lane
		else if (x >= 812 && x < 1236) targetLane = 1; // Center lane
		else if (x >= 1236 && x < 1668) targetLane = 2; // Right lane
		// Check if lane is available and card can be played
		if (targetLane >= 0 && humanPlayer.battlefield.length < 3) {
			// Check if target lane is already occupied
			var laneOccupied = false;
			for (var i = 0; i < humanPlayer.battlefield.length; i++) {
				if (humanPlayer.battlefield[i].laneIndex === targetLane) {
					laneOccupied = true;
					break;
				}
			}
			if (!laneOccupied && humanPlayer.playCard(draggedCard)) {
				draggedCard.targetLane = targetLane;
				draggedCard = null;
				selectedCard = null;
				updateUI();
				arrangeHand();
				arrangeBattlefield();
			}
		}
	} else if (selectedCard && selectedCard.isOnBattlefield) {
		// Attack with selected card
		if (y < 1216) {
			// Attacking opponent area
			if (aiPlayer.battlefield.length === 0) {
				// Direct attack on player with animation
				var originalX = selectedCard.x;
				var originalY = selectedCard.y;
				tween(selectedCard, {
					x: 1024,
					y: 1000
				}, {
					duration: 400,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Deal damage when reaching opponent area
						aiPlayer.takeDamage(selectedCard.cardData.attack);
						// Animate return to original position
						tween(selectedCard, {
							x: originalX,
							y: originalY
						}, {
							duration: 400,
							easing: tween.easeIn
						});
					}
				});
				selectedCard.hasAttacked = true;
				selectedCard.children[0].alpha = 0.7;
			} else {
				// Attack enemy creature in the same lane only
				for (var i = 0; i < aiPlayer.battlefield.length; i++) {
					var target = aiPlayer.battlefield[i];
					// Only allow attacking cards in the same lane
					if (target.laneIndex === selectedCard.laneIndex) {
						var targetBounds = {
							left: target.x - 90,
							right: target.x + 90,
							top: target.y - 125,
							bottom: target.y + 125
						};
						if (x >= targetBounds.left && x <= targetBounds.right && y >= targetBounds.top && y <= targetBounds.bottom) {
							selectedCard.attack(target);
							break;
						}
					}
				}
			}
		}
		selectedCard = null;
	}
	if (draggedCard) {
		arrangeHand();
		draggedCard = null;
	}
	// Remove dead cards
	for (var i = aiPlayer.battlefield.length - 1; i >= 0; i--) {
		if (aiPlayer.battlefield[i].currentHealth <= 0) {
			var deadCard = aiPlayer.battlefield[i];
			game.removeChild(deadCard);
			aiPlayer.battlefield.splice(i, 1);
		}
	}
	updateUI();
	arrangeBattlefield();
	checkGameOver();
};
game.update = function () {
	if (gamePhase === "playing") {
		updateUI();
	}
};
// Initial setup
updateUI();
arrangeHand();
arrangeBattlefield();