/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0
});

/**** 
* Classes
****/ 
var Miner = Container.expand(function () {
	var self = Container.call(this);
	self.sprite = self.attachAsset('miner', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.gridX = 0;
	self.gridY = 0;
	self.moving = false;
	self.moveTo = function (x, y) {
		if (self.moving) {
			return false;
		}
		var oldX = self.gridX;
		var oldY = self.gridY;
		self.gridX = x;
		self.gridY = y;
		self.moving = true;
		tween(self, {
			x: x * TILE_SIZE,
			y: y * TILE_SIZE
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.moving = false;
			}
		});
		return true;
	};
	return self;
});
var Monster = Container.expand(function (startX, startY, patrolRange) {
	var self = Container.call(this);
	self.sprite = self.attachAsset('monster', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.gridX = startX;
	self.gridY = startY;
	self.patrolRange = patrolRange || 3;
	self.startX = startX;
	self.moving = false;
	self.direction = 1; // 1 right, -1 left
	self.update = function () {
		if (self.moving) {
			return;
		}
		if (Math.abs(self.gridX - self.startX) >= self.patrolRange) {
			self.direction *= -1;
		}
		var nextX = self.gridX + self.direction;
		if (isValidMove(nextX, self.gridY)) {
			self.moveTo(nextX, self.gridY);
		} else {
			self.direction *= -1;
		}
	};
	self.moveTo = function (x, y) {
		self.moving = true;
		self.gridX = x;
		self.gridY = y;
		tween(self, {
			x: x * TILE_SIZE,
			y: y * TILE_SIZE
		}, {
			duration: 300,
			easing: tween.linear,
			onFinish: function onFinish() {
				self.moving = false;
			}
		});
	};
	return self;
});
var StatusBar = Container.expand(function (type, width, height) {
	var self = Container.call(this);
	self.maxValue = 100;
	self.currentValue = 100;
	var borderAsset = type + 'Border';
	var fillerAsset = type;
	self.border = self.attachAsset(borderAsset, {
		anchorX: 0,
		anchorY: 0
	});
	self.filler = self.attachAsset(fillerAsset, {
		anchorX: 0,
		anchorY: 0,
		x: 2,
		y: 2
	});
	self.setValue = function (value) {
		self.currentValue = Math.max(0, Math.min(self.maxValue, value));
		var percentage = self.currentValue / self.maxValue;
		self.filler.scale.x = percentage;
	};
	return self;
});
var Tile = Container.expand(function (type, x, y) {
	var self = Container.call(this);
	self.type = type;
	self.gridX = x;
	self.gridY = y;
	self.revealed = false;
	var assetId;
	switch (type) {
		case 'wall':
			assetId = 'wall';
			break;
		case 'dirt':
			assetId = 'dirt';
			break;
		case 'gemCommon':
			assetId = 'gemCommon';
			break;
		case 'gemRare':
			assetId = 'gemRare';
			break;
		case 'gemEpic':
			assetId = 'gemEpic';
			break;
		case 'lava':
			assetId = 'lava';
			break;
		default:
			assetId = 'dirt';
			break;
	}
	self.sprite = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.reveal = function () {
		if (self.revealed) {
			return;
		}
		self.revealed = true;
		if (self.type === 'dirt') {
			tween(self.sprite, {
				alpha: 0
			}, {
				duration: 300,
				onFinish: function onFinish() {
					self.sprite.visible = false;
				}
			});
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Constants
var GRID_WIDTH = 15;
var GRID_HEIGHT = 100;
var TILE_SIZE = 100;
var VIEWPORT_HEIGHT = 20; // Number of rows visible at once
var OXYGEN_DECREASE_RATE = 0.1;
var DRILL_DECREASE_AMOUNT = 5;
var MAX_DEPTH = 95; // Maximum depth to consider for win condition
// Game variables
var grid = [];
var miner;
var score = 0;
var depth = 0;
var monsters = [];
var viewportOffset = 0;
var oxygenBar;
var durabilityBar;
var scoreText;
var depthText;
var gameActive = true;
// Initialize game elements
game.setBackgroundColor(0x222222);
function initGame() {
	// Reset game variables
	grid = [];
	monsters = [];
	score = 0;
	depth = 0;
	viewportOffset = 0;
	gameActive = true;
	// Generate the grid
	generateGrid();
	// Create miner
	miner = new Miner();
	miner.x = Math.floor(GRID_WIDTH / 2) * TILE_SIZE;
	miner.y = 0;
	miner.gridX = Math.floor(GRID_WIDTH / 2);
	miner.gridY = 0;
	game.addChild(miner);
	// Spawn monsters
	spawnMonsters();
	// Create UI
	createUI();
	// Start background music
	LK.playMusic('bgMusic');
}
function createUI() {
	// Oxygen bar
	oxygenBar = new StatusBar('oxygen');
	oxygenBar.x = 20;
	oxygenBar.y = 20;
	LK.gui.topLeft.addChild(oxygenBar);
	// Durability bar
	durabilityBar = new StatusBar('durability');
	durabilityBar.x = 20;
	durabilityBar.y = 50;
	LK.gui.topLeft.addChild(durabilityBar);
	// Score text
	scoreText = new Text2("Score: 0", {
		size: 40,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(1, 0);
	LK.gui.topRight.addChild(scoreText);
	// Depth text
	depthText = new Text2("Depth: 0m", {
		size: 40,
		fill: 0xFFFFFF
	});
	depthText.anchor.set(0.5, 0);
	LK.gui.top.addChild(depthText);
	// Restart button
	var restartButton = new Text2("Restart", {
		size: 40,
		fill: 0xFFFFFF
	});
	restartButton.anchor.set(0.5, 0);
	restartButton.x = 1024; // Centered horizontally
	restartButton.y = 100; // Positioned below the depth text
	restartButton.interactive = true;
	restartButton.buttonMode = true;
	restartButton.on('pointerdown', function () {
		initGame(); // Restart the game when the button is pressed
	});
	LK.gui.top.addChild(restartButton);
	// Movement buttons
	var buttonSize = 80;
	var buttonOffset = 20;
	// Left button
	var leftButton = new Text2("<", {
		size: 40,
		fill: 0xFFFFFF
	});
	leftButton.anchor.set(0.5, 0.5);
	leftButton.x = buttonOffset + buttonSize / 2;
	leftButton.y = 2732 - buttonOffset - buttonSize / 2;
	leftButton.interactive = true;
	leftButton.buttonMode = true;
	leftButton.on('pointerdown', function () {
		handleMovement(-1, 0);
	});
	LK.gui.bottomLeft.addChild(leftButton);
	// Right button
	var rightButton = new Text2(">", {
		size: 40,
		fill: 0xFFFFFF
	});
	rightButton.anchor.set(0.5, 0.5);
	rightButton.x = buttonOffset + buttonSize * 1.5;
	rightButton.y = 2732 - buttonOffset - buttonSize / 2;
	rightButton.interactive = true;
	rightButton.buttonMode = true;
	rightButton.on('pointerdown', function () {
		handleMovement(1, 0);
	});
	LK.gui.bottomLeft.addChild(rightButton);
	// Up button
	var upButton = new Text2("^", {
		size: 40,
		fill: 0xFFFFFF
	});
	upButton.anchor.set(0.5, 0.5);
	upButton.x = buttonOffset + buttonSize;
	upButton.y = 2732 - buttonOffset - buttonSize * 1.5;
	upButton.interactive = true;
	upButton.buttonMode = true;
	upButton.on('pointerdown', function () {
		handleMovement(0, -1);
	});
	LK.gui.bottomLeft.addChild(upButton);
	// Down button
	var downButton = new Text2("v", {
		size: 40,
		fill: 0xFFFFFF
	});
	downButton.anchor.set(0.5, 0.5);
	downButton.x = buttonOffset + buttonSize;
	downButton.y = 2732 - buttonOffset - buttonSize / 2;
	downButton.interactive = true;
	downButton.buttonMode = true;
	downButton.on('pointerdown', function () {
		handleMovement(0, 1);
	});
	LK.gui.bottomLeft.addChild(downButton);
}
function generateGrid() {
	// Clear existing grid
	for (var i = 0; i < grid.length; i++) {
		for (var j = 0; j < grid[i].length; j++) {
			if (grid[i][j] && grid[i][j].parent) {
				grid[i][j].parent.removeChild(grid[i][j]);
			}
		}
	}
	// Generate new grid
	for (var y = 0; y < GRID_HEIGHT; y++) {
		grid[y] = [];
		for (var x = 0; x < GRID_WIDTH; x++) {
			var type = 'dirt';
			// Edge walls
			if (x === 0 || x === GRID_WIDTH - 1) {
				type = 'wall';
			}
			// Random walls
			else if (y > 0 && Math.random() < 0.1) {
				type = 'wall';
			}
			// Gems (more valuable as you go deeper)
			else if (Math.random() < 0.05) {
				if (y > 60) {
					type = 'gemEpic';
				} else if (y > 30) {
					type = 'gemRare';
				} else {
					type = 'gemCommon';
				}
			}
			// Lava (more common as you go deeper)
			else if (y > 10 && Math.random() < 0.02 + y / 1000) {
				type = 'lava';
			}
			var tile = new Tile(type, x, y);
			tile.x = x * TILE_SIZE;
			tile.y = y * TILE_SIZE;
			grid[y][x] = tile;
			game.addChild(tile);
			// Initial tiles should be visible
			if (y < 2) {
				tile.reveal();
			}
		}
	}
}
function spawnMonsters() {
	// Add monsters at various depths
	for (var i = 0; i < 10; i++) {
		var depth = 10 + i * 8;
		var x = 1 + Math.floor(Math.random() * (GRID_WIDTH - 2));
		var monster = new Monster(x, depth, 3 + Math.floor(i / 3));
		monster.x = x * TILE_SIZE;
		monster.y = depth * TILE_SIZE;
		monsters.push(monster);
		game.addChild(monster);
	}
}
function updateViewport() {
	var targetOffset = Math.max(0, miner.gridY - Math.floor(VIEWPORT_HEIGHT / 2));
	if (targetOffset !== viewportOffset) {
		viewportOffset = targetOffset;
		// Adjust all elements based on new viewport
		for (var y = 0; y < GRID_HEIGHT; y++) {
			for (var x = 0; x < GRID_WIDTH; x++) {
				if (grid[y] && grid[y][x]) {
					grid[y][x].y = (y - viewportOffset) * TILE_SIZE;
				}
			}
		}
		// Adjust monsters
		for (var i = 0; i < monsters.length; i++) {
			monsters[i].y = (monsters[i].gridY - viewportOffset) * TILE_SIZE;
		}
		// Adjust miner
		miner.y = (miner.gridY - viewportOffset) * TILE_SIZE;
	}
}
function isValidMove(x, y) {
	// Check bounds
	if (x < 0 || x >= GRID_WIDTH || y < 0 || y >= GRID_HEIGHT) {
		return false;
	}
	// Check if position is valid
	if (!grid[y] || !grid[y][x]) {
		return false;
	}
	// Can't move through walls
	if (grid[y][x].type === 'wall') {
		return false;
	}
	return true;
}
function handleTileInteraction(x, y) {
	if (!grid[y] || !grid[y][x]) {
		return;
	}
	var tile = grid[y][x];
	// Reveal the tile
	tile.reveal();
	// Collect gems
	if (tile.type.includes('gem')) {
		var gemValue = 0;
		if (tile.type === 'gemCommon') {
			gemValue = 10;
		} else if (tile.type === 'gemRare') {
			gemValue = 25;
		} else if (tile.type === 'gemEpic') {
			gemValue = 50;
		}
		score += gemValue;
		scoreText.setText("Score: " + score);
		// Play gem collection sound
		LK.getSound('gemCollect').play();
		// Change tile to dirt after collection
		tile.type = 'dirt';
	}
	// Check for lava
	if (tile.type === 'lava') {
		LK.getSound('danger').play();
		LK.effects.flashScreen(0xFF0000, 1000);
		endGame(false);
	}
	// Decrease drill durability for dirt and wall
	if (tile.type === 'dirt' || tile.type === 'wall') {
		durabilityBar.setValue(durabilityBar.currentValue - DRILL_DECREASE_AMOUNT);
		LK.getSound('dig').play();
		// Check if drill is broken
		if (durabilityBar.currentValue <= 0) {
			endGame(false);
		}
	}
	// Update depth if this is a new deepest point
	if (y > depth) {
		depth = y;
		depthText.setText("Depth: " + depth + "m");
		// Check win condition
		if (depth >= MAX_DEPTH) {
			endGame(true);
		}
	}
}
function checkMonsterCollision() {
	for (var i = 0; i < monsters.length; i++) {
		if (monsters[i].gridX === miner.gridX && monsters[i].gridY === miner.gridY) {
			LK.getSound('danger').play();
			LK.effects.flashScreen(0xFF0000, 1000);
			endGame(false);
			break;
		}
	}
}
function endGame(win) {
	gameActive = false;
	// Update high score if needed
	if (score > storage.highScore) {
		storage.highScore = score;
	}
	if (win) {
		LK.showYouWin();
	} else {
		LK.showGameOver();
	}
}
function handleMovement(dx, dy) {
	if (!gameActive || miner.moving) {
		return;
	}
	var newX = miner.gridX + dx;
	var newY = miner.gridY + dy;
	if (isValidMove(newX, newY)) {
		if (miner.moveTo(newX, newY)) {
			handleTileInteraction(newX, newY);
		}
	}
}
game.down = function (x, y) {
	if (!gameActive) {
		return;
	}
	// Convert screen coordinates to grid coordinates
	var gridX = Math.floor(x / TILE_SIZE);
	var gridY = Math.floor(y / TILE_SIZE) + viewportOffset;
	// Check if it's a valid move (only adjacent tiles)
	var dx = gridX - miner.gridX;
	var dy = gridY - miner.gridY;
	// Only allow moving to adjacent tiles (manhattan distance of 1)
	if (Math.abs(dx) + Math.abs(dy) === 1) {
		handleMovement(dx, dy);
	}
};
// Add swipe right gesture to move miner right
game.swipeRight = function () {
	if (!gameActive || miner.moving) {
		return;
	}
	var newX = miner.gridX + 1;
	var newY = miner.gridY;
	if (isValidMove(newX, newY)) {
		if (miner.moveTo(newX, newY)) {
			handleTileInteraction(newX, newY);
		}
	}
};
game.update = function () {
	if (!gameActive) {
		return;
	}
	// Update viewport position
	updateViewport();
	// Update oxygen level
	oxygenBar.setValue(oxygenBar.currentValue - OXYGEN_DECREASE_RATE);
	if (oxygenBar.currentValue <= 0) {
		endGame(false);
	}
	// Update monsters
	for (var i = 0; i < monsters.length; i++) {
		monsters[i].update();
	}
	// Check for monster collisions
	checkMonsterCollision();
	// Reveal nearby tiles
	for (var dy = -1; dy <= 1; dy++) {
		for (var dx = -1; dx <= 1; dx++) {
			var nx = miner.gridX + dx;
			var ny = miner.gridY + dy;
			if (nx >= 0 && nx < GRID_WIDTH && ny >= 0 && ny < GRID_HEIGHT && grid[ny] && grid[ny][nx]) {
				grid[ny][nx].reveal();
			}
		}
	}
};
// Initialize the game
initGame();