/**** 
* Classes
****/ 
// Assets will be automatically created and loaded by the LK engine based on their usage in the code.
// Define a Tile class to represent each tile in the grid
var Tile = Container.expand(function () {
	var self = Container.call(this);
	self.type = 'empty'; // Default type
	self.baseTint = 0x8FBE00;
	self.baseTintLight = 0x5ED000;
	self.connections = []; // Connection points for pipes
	self.position = {
		x: 0,
		y: 0
	}; // Grid position
	// Method to set the tile type
	self.setType = function (type) {
		self.type = type;
		var baseTileAsset = type == 'start' || type == 'end' || type == 'fixed' ? 'baseTile' : 'baseMobileTile';
		if (type == 'empty') {
			return;
		}
		// Attach baseTile asset
		self.baseTile = self.attachAsset(baseTileAsset, {
			anchorX: 0.5,
			anchorY: 0.5,
			width: tileSize,
			height: tileSize,
			tint: 0xFFFFFF // 0x9EBE7E // vert
		});
		// Set default dimensions based on tileSize
		self.width = tileSize;
		self.height = tileSize;
		// Attach appropriate asset based on type
		switch (type) {
			case 'start':
				self.attachAsset('startTile', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 20,
					y: 55,
					tint: self.baseTint
				});
				self.attachAsset('vane', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 20,
					y: 15,
					tint: self.baseTint
				});
				break;
			case 'end':
				self.attachAsset('endTile', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: 55,
					tint: self.baseTint
				});
				break;
			case 'fixed':
				// self.attachAsset('fixedPipe', {
				// 	anchorX: 0.5,
				// 	anchorY: 0.5
				// });
				self.attachAsset('straightPipe', {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -40,
					tint: self.baseTint
				});
				self.attachAsset('straightPipe', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleY: -1,
					y: 30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: -1,
					x: 30,
					tint: self.baseTint
				});
				break;
			case 'straightPipeH':
				self.attachAsset('straightPipe', {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -40,
					tint: self.baseTint
				});
				self.attachAsset('straightPipe', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleY: -1,
					y: 30,
					tint: self.baseTint
				});
				break;
			case 'straightPipeV':
				self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: -1,
					x: 30,
					tint: self.baseTint
				});
				// Water
				self.water1 = self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -30,
					tint: self.baseTintLight
				});
				self.water2 = self.attachAsset('straightPipeV', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: -1,
					x: 30,
					tint: self.baseTintLight
				});
				break;
			case 'cornerPipe':
				self.attachAsset('cornerPipe', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -60,
					y: -60,
					tint: self.baseTintLight
				});
				break;
			//case 'empty':
			default:
				// self.attachAsset('emptyTile', {
				// 	anchorX: 0.5,
				// 	anchorY: 0.5
				// });
				break;
		}
	};
	// Method to update the tile's position
	self.updatePosition = function (x, y) {
		self.position.x = x;
		self.position.y = y;
		if (self.baseTile) {
			self.baseTile.width = tileSize;
			self.baseTile.height = tileSize;
		}
		self.x = x * tileSize + gridBoard.x - gridBoard.width / 2 + tileSize / 2 + boardOffsetX;
		self.y = y * tileSize + gridBoard.y - gridBoard.height / 2 + tileSize / 2 + boardOffsetY;
		log('Tile index:', x, y, 'Tile position:', self.x, self.y, 'Tile dimensions:', self.width, self.height, ' self:', self);
	};
	self.setRotation = function (direction) {
		self.rotation = Math.PI * 0.5;
		log('Tile position:', self.x, self.y, 'Tile rotation:', self.rotation);
	};
	self.setType(self.type);
	// Add update function to animate the alpha of self.water1 and self.water2
	self.update = function () {
		if (self.water1 && self.water2) {
			var tintValue = Math.abs(Math.sin(LK.ticks / 60)) * 0xFFFFFF; // Calculate tint value from black to white
			self.water1.tint = tintValue;
			self.water2.tint = tintValue;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Add a global log() function that makes console.debug if global debug is true
1;
function log() {
	if (debug) {
		var _console;
		(_console = console).log.apply(_console, arguments);
	}
}
var debug = true;
var tileSize = 400;
var boardOffsetX = 90;
var boardOffsetY = 90;
// Add the gridBoard to the game and place it at the center
var gridBoard = LK.getAsset('gridBoard', {
	anchorX: 0.5,
	anchorY: 0.5
});
game.addChild(gridBoard);
gridBoard.x = 2048 / 2;
gridBoard.y = 2732 / 2;
// Log gridBoard dimensions and location
console.log("gridBoard width: " + gridBoard.width);
console.log("gridBoard height: " + gridBoard.height);
console.log("gridBoard x position: " + gridBoard.x);
console.log("gridBoard y position: " + gridBoard.y);
// Initialize the grid
var grid = [];
var gridSize = 4; // 4x4 grid
// Create the grid and populate it with tiles
for (var i = 0; i < gridSize; i++) {
	grid[i] = [];
	for (var j = 0; j < gridSize; j++) {
		var tile = new Tile();
		tile.updatePosition(i, j); // Update the position to be in terms of grid indexes
		grid[i][j] = tile;
		game.addChild(tile);
	}
}
// Set up initial puzzle configuration
grid[0][0].setType('start');
grid[3][3].setType('end');
grid[1][0].setType('fixed');
grid[2][2].setType('straightPipeH');
grid[1][1].setType('straightPipeV');
grid[1][2].setType('cornerPipe');
grid[3][2].setType('cornerPipe');
// Set up initial rotations
grid[3][3].setRotation('left');
// Function to handle sliding of tiles
function slideTiles(direction) {
	// Implement sliding logic based on direction
	// Validate moves and update tile positions
}
// Function to trace the water path
function traceWaterPath() {
	// Implement path tracing logic
	// Check if the path is complete from start to end
}
// Event listeners for user interactions
game.down = function (x, y, obj) {
	// Determine which tile was clicked and initiate sliding
};
game.up = function (x, y, obj) {
	// Finalize sliding and check for puzzle completion
};
// Game update loop
game.update = function () {
	// Continuously check for path completion
	traceWaterPath();
};
// Initialize the game with a simple puzzle
function initializePuzzle() {
	log("initializePuzzle...");
	// Set up a solvable puzzle configuration
	// Ensure start and end tiles are connected through movable pipes
}
// Add a global 'debug' variable
initializePuzzle();