/**** 
* Classes
****/ 
var Tile = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.type = 'empty';
	self.baseTint = 0x8FBE00;
	self.baseTintLight = 0x5ED000;
	self.maxWaterSize = 260;
	self.flowSpeed = 12;
	self.startFlowTicks = 0;
	self.flow = false;
	self.connections = [];
	self.position = {
		x: 0,
		y: 0
	};
	self.rotation = 0;
	// Methods
	self.setType = function (type, x, y) {
		self.type = type;
		var baseTileAsset = type == 'start' || type == 'end' || puzzleManager && puzzleManager.levelConfigs && puzzleManager.levelConfigs[puzzleManager.currentLevel] && puzzleManager.levelConfigs[puzzleManager.currentLevel].fixedTiles.includes(x + ',' + y) ? '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
		});
		self.width = tileSize;
		self.height = tileSize;
		switch (type) {
			case 'start':
				self.attachAsset('startPipeAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 20,
					y: 55,
					tint: self.baseTint
				});
				self.valve = self.attachAsset('vane', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 20,
					y: 15,
					tint: self.baseTint
				});
				self.water = self.attachAsset('waterV', {
					anchorX: 0.5,
					anchorY: 0,
					x: -0,
					y: -120,
					height: 0,
					visible: false,
					dir: ''
				});
				break;
			case 'end':
				self.attachAsset('endPipeAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: 55,
					tint: self.baseTint
				});
				self.water = self.attachAsset('waterV', {
					anchorX: 0.5,
					anchorY: 0,
					x: -0,
					y: -120,
					height: 0,
					visible: false,
					dir: ''
				});
				self.fountain = self.attachAsset('fontain', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: 0,
					width: 0,
					height: 0,
					visible: false
				});
				break;
			case 'crossPipe':
				self.attachAsset('straightPipeHAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -40,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeHAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleY: -1,
					y: 30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeVAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeVAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: -1,
					x: 30,
					tint: self.baseTint
				});
				self.water = self.attachAsset('waterV', {
					anchorX: 0.5,
					anchorY: 0,
					x: -0,
					y: -120,
					height: 0,
					visible: false,
					dir: ''
				});
				break;
			case 'straightPipeH':
				self.attachAsset('straightPipeHAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -40,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeHAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleY: -1,
					y: 30,
					tint: self.baseTint
				});
				self.water = self.attachAsset('waterH', {
					anchorX: 0,
					anchorY: 0.5,
					x: -130,
					y: -5,
					width: 0,
					visible: false,
					dir: 'lr'
				});
				break;
			case 'straightPipeV':
				self.attachAsset('straightPipeVAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -30,
					tint: self.baseTint
				});
				self.attachAsset('straightPipeVAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: -1,
					x: 30,
					tint: self.baseTint
				});
				self.water = self.attachAsset('waterV', {
					anchorX: 0.5,
					anchorY: 0,
					x: -0,
					y: -120,
					height: 0,
					visible: false,
					dir: 'tb'
				});
				break;
			case 'cornerPipe':
				self.attachAsset('cornerPipeAsset', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: -60,
					y: -60,
					tint: self.baseTintLight
				});
				// Corner part of the water
				self.waterCorner = self.attachAsset('waterCorner', {
					anchorX: 1,
					anchorY: 1,
					width: 108,
					height: 108,
					x: -65,
					y: -65,
					rotation: -Math.PI / 2,
					//-Math.PI / 2, at start to -Math.PI,
					visible: false,
					dir: ''
				});
				// Vertical part of the water
				self.waterV = self.attachAsset('waterV', {
					anchorX: 0.5,
					anchorY: 0,
					width: 110,
					x: -120,
					y: -5,
					rotation: -Math.PI / 2,
					height: 0,
					visible: false,
					dir: ''
				});
				// Horizontal part of the water
				self.waterH = self.attachAsset('waterH', {
					anchorX: 0,
					anchorY: 0.5,
					x: -5,
					y: -50,
					//-15,
					width: 0,
					height: 112,
					rotation: -Math.PI / 2,
					visible: false,
					dir: ''
				});
				// Corner part of the water
				self.waterCornerCover = self.attachAsset('waterCorner', {
					anchorX: 1,
					anchorY: 1,
					width: 108,
					height: 108,
					x: -65,
					y: -65,
					rotation: -Math.PI,
					visible: false,
					dir: ''
				});
				break;
		}
	};
	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) {
		switch (direction) {
			case 'left':
				self.rotation = Math.PI * 0.5;
				break;
			case 'right':
				self.rotation = -Math.PI * 0.5;
				break;
			case 'up':
				self.rotation = 0;
				break;
			case 'down':
				self.rotation = Math.PI;
				break;
		}
		log('Tile position:', self.x, self.y, 'Tile rotation:', self.rotation);
	};
	self.update = function () {
		if (self.flow) {
			if (!self.startFlowTicks) {
				self.startFlowTicks = LK.ticks;
				if (self.water) {
					self.water.visible = true;
				}
				if (self.waterV) {
					self.waterV.visible = true;
				}
				if (self.waterH) {
					self.waterH.visible = true;
				}
			}
			if (self.type === 'start') {
				// Rotate valve for start pipe
				var rotationValue = (LK.ticks - self.startFlowTicks) * 0.1;
				if (self.valve) {
					self.valve.rotation = rotationValue;
				}
				if (rotationValue >= Math.PI * 2) {
					self.flow = false;
				}
			} else if (self.type === 'cornerPipe') {
				// Corner pipe animation
				var progress = (LK.ticks - self.startFlowTicks) * self.flowSpeed; // Accelerate water speed
				var thirdSize = self.maxWaterSize / 3 - 10; // Split animation into three phases
				var sidesSize = self.maxWaterSize / 3; //+ 40;
				if (progress < self.maxWaterSize) {
					// Phase 1: Vertical water grows
					if (progress < thirdSize) {
						if (self.waterV) {
							self.waterV.height = progress;
						}
					}
					// Phase 2: Corner water appears and rotates
					else if (progress < thirdSize * 2) {
						if (self.waterV) {
							self.waterV.height = thirdSize; // Keep vertical at full first-phase height
						}
						if (self.waterCorner) {
							self.waterCorner.visible = true;
							self.waterCorner.alpha = Math.min(Math.max(0, ((progress - thirdSize) / thirdSize - 0.5) * 2, 0), 1); // Animate alpha from 0 to 1
							// Calculate rotation from -PI/2 to -PI
							var rotationProgress = (progress - thirdSize) / thirdSize; // 0 to 1
							self.waterCorner.rotation = -Math.PI / 2 - rotationProgress * Math.PI / 2;
						}
					}
					// Phase 3: Horizontal water grows
					else {
						if (self.waterV) {
							self.waterV.height = thirdSize;
						}
						if (self.waterCorner) {
							self.waterCorner.visible = true;
							self.waterCorner.alpha = 1;
							self.waterCorner.rotation = -Math.PI; // Keep at final rotation
						}
						if (self.waterH) {
							self.waterH.visible = true;
							self.waterH.width = Math.min(progress - thirdSize * 2, sidesSize);
						}
					}
				} else {
					self.flow = false;
				}
			} else if (self.type === 'end' && self.fountain) {
				// Animate fountain growth
				var sizeValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
				if (sizeValue < self.maxWaterSize) {
					self.fountain.width = sizeValue;
					self.fountain.height = sizeValue;
					self.fountain.visible = true;
				} else {
					self.flow = false;
					if (!waterDropInterval) {
						createWaterDrops(self.x, self.y, game);
						waterDropInterval = LK.setInterval(function () {
							createWaterDrops(self.x, self.y, game);
						}, 500 + Math.random() * 500);
					}
				}
			} else if (self.water) {
				// Regular pipe animation
				var heightValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
				if (self.water.dir != '' && heightValue < self.maxWaterSize) {
					if (self.water.dir == 'tb') {
						self.water.height = heightValue;
					}
					if (self.water.dir == 'lr') {
						self.water.width = heightValue;
					}
				} else {
					self.flow = false;
				}
			}
		}
		if (self.type === 'end' && self.fountain && self.fountain.visible) {
			self.fountain.rotation += 0.1; // Rotate the fountain indefinitely
		}
	};
	self.setType(self.type);
	return self;
});
var WaterDrop = Container.expand(function () {
	var self = Container.call(this);
	var waterDropGraphics = self.attachAsset('waterDrop', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set initial tint to a random  color
	var rainbowColors = [0xC7ECFE, 0xDDFDFF, 0xF4FFFF, 0xC8F8FF]; // Rainbow [0xFF0000, 0xFF7F00, 0xFFFF00, 0x00FF00, 0x0000FF, 0x4B0082, 0x8B00FF];
	waterDropGraphics.tint = rainbowColors[Math.floor(Math.random() * rainbowColors.length)];
	self.vx = 0;
	self.vy = 0;
	self.life = 0;
	self.size = 7;
	self.alpha = 0.75 + Math.random() * 0.25;
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		self.rotation = Math.atan2(self.vy, self.vx) + Math.PI * 0.55;
		// Animate size 
		var sizeProgress = (120 - self.life) / 120; // Assuming life starts at 120
		waterDropGraphics.width = self.size + sizeProgress * self.size * 2;
		waterDropGraphics.height = self.size * 2 + sizeProgress * self.size * 4;
		self.life--;
		if (self.life <= 0) {
			self.visible = false;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var PuzzleManager = function PuzzleManager() {
	var self = this;
	// Properties
	self.currentLevel = 1;
	self.selectedTile = null;
	self.isComplete = false;
	// Methods
	self.selectTile = function (x, y) {
		// Convert screen coordinates to grid coordinates
		var gridX = Math.floor((x - boardOffsetX) / tileSize);
		var gridY = Math.floor((y - boardOffsetY) / tileSize);
		// Check if coordinates are within grid bounds
		if (gridX >= 0 && gridX < 3 && gridY >= 0 && gridY < 3) {
			self.selectedTile = self.grid[gridY][gridX];
		}
	};
	self.reset = function () {
		self.currentLevel = 1;
		self.selectedTile = null;
		self.isComplete = false;
		self.initPuzzle();
	};
	self.initPuzzle = function () {
		// Initialize grid
		self.grid = [];
		for (var i = 0; i < 3; i++) {
			self.grid[i] = [];
			for (var j = 0; j < 3; j++) {
				var tile = new Tile();
				self.grid[i][j] = tile;
				game.addChild(tile);
			}
		}
	};
	self.moveTile = function (direction) {
		if (!self.selectedTile) {
			return;
		}
		var x = self.selectedTile.position.x;
		var y = self.selectedTile.position.y;
		var newX = x;
		var newY = y;
		// Calculate new position
		switch (direction) {
			case 'right':
				newX++;
				break;
			case 'left':
				newX--;
				break;
			case 'down':
				newY++;
				break;
			case 'up':
				newY--;
				break;
		}
		// Swap tiles
		var movingTile = self.selectedTile;
		var emptyTile = self.grid[newY][newX];
		// Update grid
		self.grid[newY][newX] = movingTile;
		self.grid[y][x] = emptyTile;
		// Update positions
		movingTile.updatePosition(newX, newY);
		if (emptyTile) {
			emptyTile.updatePosition(x, y);
		}
		// Clear selection
		self.selectedTile = null;
	};
	self.checkWinCondition = function () {
		// Find start position
		var startX = -1,
			startY = -1;
		for (var i = 0; i < 3; i++) {
			for (var j = 0; j < 3; j++) {
				if (self.grid[i][j].type === 'start') {
					startX = i;
					startY = j;
					break;
				}
			}
			if (startX !== -1) {
				break;
			}
		}
		// Use a Set to track visited positions
		var visited = [];
		// Check if we can reach the end tile
		return this.canReachEnd(startX, startY + 1, visited); // Start flowing down from start
	};
	self.canReachEnd = function (x, y, visited) {
		// Check bounds
		if (x < 0 || x >= 3 || y < 0 || y >= 3) {
			return false;
		}
		// Create position key
		var key = x + ',' + y;
		if (visited.includes(key)) {
			return false;
		}
		visited.push(key);
		var tile = self.grid[x][y];
		if (!tile || tile.type === 'empty') {
			return false;
		}
		// If we reached the end, success!
		if (tile.type === 'end') {
			return true;
		}
		// Get next possible positions based on current tile type and rotation
		var nextPositions = [];
		switch (tile.type) {
			case 'straightPipeV':
				nextPositions.push([x, y - 1], [x, y + 1]); // Up and down
				break;
			case 'straightPipeH':
				nextPositions.push([x - 1, y], [x + 1, y]); // Left and right
				break;
			case 'cornerPipe':
				// Check rotation to determine flow direction
				if (tile.rotation === Math.PI * 0.5) {
					// Left rotation
					nextPositions.push([x, y - 1], [x + 1, y]); // Up and right
				}
				// Add other rotations as needed
				break;
			case 'crossPipe':
				nextPositions.push([x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]); // All directions
				break;
		}
		// Try each possible next position
		for (var i = 0; i < nextPositions.length; i++) {
			var nextX = nextPositions[i][0];
			var nextY = nextPositions[i][1];
			if (this.canReachEnd(nextX, nextY, visited)) {
				return true;
			}
		}
		return false;
	};
	return self;
};
/**** 
* Game Variables
****/ 
var debug = true;
function log() {
	if (debug) {
		console.log.apply(console, arguments);
	}
}
// Game constants
var tileSize = 400;
var boardOffsetX = 90;
var boardOffsetY = -100;
// Game state variables
var GAME_STATE = {
	INIT: 'INIT',
	MENU: 'MENU',
	NEW_ROUND: 'NEW_ROUND',
	PLAYING: 'PLAYING',
	SCORE: 'SCORE'
};
var currentState = GAME_STATE.INIT;
var isPlaying = true;
var gridBoard;
var isMouseDown = false;
var startX = 0;
var startY = 0;
var selectedTile = null;
var dragThreshold = 20;
var levelText;
var waterDrops = [];
var waterDropInterval;
var puzzleManager;
/**** 
* Helper Functions
****/ 
function createWaterDrops(x, y, game) {
	for (var i = 0; i < 10; i++) {
		var waterDrop = waterDrops.find(function (drop) {
			return !drop.visible;
		});
		if (!waterDrop) {
			waterDrop = new WaterDrop();
			waterDrops.push(waterDrop);
			game.addChild(waterDrop);
		}
		waterDrop.x = x;
		waterDrop.y = y;
		var angle = Math.random() * Math.PI * 2;
		var speed = Math.random() * 3 + 3;
		var easeFactor = Math.random() * 0.05 + 0.95; // Random easing factor between 0.95 and 1.0
		waterDrop.vx = Math.cos(angle) * speed * easeFactor;
		waterDrop.vy = Math.sin(angle) * speed * easeFactor;
		waterDrop.life = 120;
		waterDrop.visible = true;
	}
}
/**** 
* Game State Management
****/ 
function initMenuState() {
	// Show level selection UI
	isPlaying = false;
	levelText.visible = true;
	levelText.text = "Level 1\nTap to Start";
}
function handleMenuLoop() {
	// Update any menu animations here
}
function cleanMenuState() {
	levelText.text = "Level 1";
}
function initNewRoundState() {
	// Reset puzzle manager for new round
	if (puzzleManager) {
		puzzleManager.reset();
	}
	// After a short delay, transition to PLAYING state
	LK.setTimeout(function () {
		changeGameState(GAME_STATE.PLAYING);
	}, 1000);
}
function handleNewRoundLoop() {
	// Any pre-game animations can go here
}
function cleanNewRoundState() {
	// Clean up any new round state
}
function initPlayingState() {
	// Start the gameplay
	isPlaying = true;
}
function handlePlayingLoop() {
	// Update game logic
	if (puzzleManager) {
		puzzleManager.update();
		// Check if level is complete
		if (puzzleManager.isComplete) {
			changeGameState(GAME_STATE.SCORE);
		}
	}
}
function cleanPlayingState() {
	isPlaying = false;
}
function initScoreState() {
	// Show score screen
	levelText.visible = true;
	levelText.text = "Level Complete!\nTap to continue";
}
function handleScoreLoop() {
	// Update any score animations
	if (puzzleManager) {
		puzzleManager.update();
	}
}
function cleanScoreState() {
	levelText.visible = false;
}
function changeGameState(newState) {
	// Clean up current state
	switch (currentState) {
		case GAME_STATE.MENU:
			cleanMenuState();
			break;
		case GAME_STATE.NEW_ROUND:
			cleanNewRoundState();
			break;
		case GAME_STATE.PLAYING:
			cleanPlayingState();
			break;
		case GAME_STATE.SCORE:
			cleanScoreState();
			break;
	}
	// Initialize new state
	currentState = newState;
	switch (newState) {
		case GAME_STATE.MENU:
			initMenuState();
			break;
		case GAME_STATE.NEW_ROUND:
			initNewRoundState();
			break;
		case GAME_STATE.PLAYING:
			initPlayingState();
			break;
		case GAME_STATE.SCORE:
			initScoreState();
			break;
	}
}
/**** 
* Event Handlers
****/ 
game.down = function (x, y, obj) {
	switch (currentState) {
		case GAME_STATE.MENU:
			changeGameState(GAME_STATE.NEW_ROUND);
			break;
		case GAME_STATE.PLAYING:
			startX = x;
			startY = y;
			isMouseDown = true;
			if (puzzleManager) {
				puzzleManager.selectTile(x, y);
			}
			break;
		case GAME_STATE.SCORE:
			changeGameState(GAME_STATE.MENU);
			break;
	}
};
game.move = function (x, y, obj) {
	if (currentState !== GAME_STATE.PLAYING || !isMouseDown || !puzzleManager || !puzzleManager.selectedTile) {
		return;
	}
	var deltaX = x - startX;
	var deltaY = y - startY;
	// Only move if drag distance exceeds threshold
	if (Math.abs(deltaX) > dragThreshold || Math.abs(deltaY) > dragThreshold) {
		var direction = null;
		if (Math.abs(deltaX) > Math.abs(deltaY)) {
			direction = deltaX > 0 ? 'right' : 'left';
		} else {
			direction = deltaY > 0 ? 'down' : 'up';
		}
		puzzleManager.moveTile(direction);
		isMouseDown = false; // Reset after move
	}
};
game.up = function (x, y, obj) {
	isMouseDown = false;
	if (currentState === GAME_STATE.PLAYING && puzzleManager) {
		puzzleManager.selectedTile = null;
	}
};
/**** 
* Main Update Loop
****/ 
function update() {
	// Handle state-specific updates
	switch (currentState) {
		case GAME_STATE.MENU:
			handleMenuLoop();
			break;
		case GAME_STATE.NEW_ROUND:
			handleNewRoundLoop();
			break;
		case GAME_STATE.PLAYING:
			handlePlayingLoop();
			break;
		case GAME_STATE.SCORE:
			handleScoreLoop();
			break;
	}
	// Update water drops
	for (var i = waterDrops.length - 1; i >= 0; i--) {
		if (waterDrops[i].visible) {
			waterDrops[i].update();
		}
	}
}
function initializeGame() {
	gridBoard = LK.getAsset('gridBoard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	gridBoard.x = 2048 / 2;
	gridBoard.y = 2732 / 2;
	game.addChild(gridBoard);
	// Initialize game assets and variables
	puzzleManager = new PuzzleManager();
	// Initialize level text
	levelText = new Text2("Level 1", {
		size: 100,
		fill: "#ffffff"
	});
	levelText.x = 2048 / 2;
	levelText.y = 200;
	levelText.anchorX = 0.5;
	// Add the level text to the game
	game.addChild(levelText);
	// Transition to menu state
	changeGameState(GAME_STATE.MENU);
}
// Start the game
initializeGame();