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

/**** 
* Classes
****/ 
var Cell = Container.expand(function () {
	var self = Container.call(this);
	var cellGraphics = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.row = 0;
	self.col = 0;
	self.piece = null;
	self.down = function (x, y, obj) {
		if (!self.piece && currentPlayer === 0) {
			placePiece(self.row, self.col);
		}
	};
	return self;
});
var CoordButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonBg = self.attachAsset('coordButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		toggleHistory();
	};
	return self;
});
var HistoryPanel = Container.expand(function () {
	var self = Container.call(this);
	var bg = self.attachAsset('historyBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var titleText = new Text2('Move History', {
		size: 65,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0);
	titleText.y = -960;
	self.addChild(titleText);
	self.historyText = new Text2('', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.historyText.anchor.set(0.5, 0);
	self.historyText.y = -880;
	self.addChild(self.historyText);
	self.updateHistory = function () {
		var historyString = '';
		for (var i = 0; i < moveHistory.length; i++) {
			var move = moveHistory[i];
			var player = move.player === 0 ? 'Orange' : 'Grey';
			historyString += player + ': ' + move.coord + '\n';
		}
		self.historyText.setText(historyString);
	};
	self.down = function (x, y, obj) {
		toggleHistory();
	};
	return self;
});
var Piece = Container.expand(function () {
	var self = Container.call(this);
	self.player = 0; // 0 for orange, 1 for grey
	self.graphics = null;
	self.setPlayer = function (player) {
		if (self.graphics) {
			self.graphics.destroy();
		}
		self.player = player;
		var assetId = player === 0 ? 'orangePiece' : 'greyPiece';
		self.graphics = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	self.flip = function () {
		tween(self, {
			scaleX: 0
		}, {
			duration: 150,
			onFinish: function onFinish() {
				self.setPlayer(1 - self.player);
				tween(self, {
					scaleX: 1
				}, {
					duration: 150
				});
			}
		});
	};
	return self;
});
var StartButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonBg = self.attachAsset('startButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		if (introScreen && !gameStarted) {
			introScreen.destroy();
			introScreen = null;
			gameStarted = true;
			initializeGame();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var BOARD_SIZE = 10;
var board = [];
var cells = [];
var currentPlayer = 0; // 0 for orange, 1 for grey
var moveHistory = [];
var historyPanel = null;
var historyVisible = false;
var introScreen = null;
var gameStarted = false;
var boardContainer = null;
// Create intro screen
introScreen = new Container();
game.addChild(introScreen);
// Add intro background
var introBg = LK.getAsset('introBackground', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
});
introScreen.addChild(introBg);
// Add start button
var startBtn = new StartButton();
startBtn.x = 1024;
startBtn.y = 2732 - 200; // 200px from bottom
introScreen.addChild(startBtn);
// Game variables that need to be accessible
var orangeCountText = null;
var greyCountText = null;
var playerText = null;
var coordButton = null;
var letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'];
var setupMode = false;
function initializeGame() {
	// Create board container
	boardContainer = new Container();
	boardContainer.x = 1024;
	boardContainer.y = 1366;
	game.addChild(boardContainer);
	// Create board background
	var boardBg = LK.getAsset('boardBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	boardContainer.addChild(boardBg);
	// Create piece count texts
	orangeCountText = new Text2('Orange: 2', {
		size: 80,
		fill: 0xFF8C00
	});
	orangeCountText.anchor.set(0, 0.5);
	orangeCountText.x = -900;
	orangeCountText.y = 1000;
	boardContainer.addChild(orangeCountText);
	greyCountText = new Text2('Grey: 2', {
		size: 80,
		fill: 0x808080
	});
	greyCountText.anchor.set(1, 0.5);
	greyCountText.x = 900;
	greyCountText.y = 1000;
	boardContainer.addChild(greyCountText);
	// Initialize board array and create cells
	var cellSpacing = 1850 / BOARD_SIZE;
	for (var row = 0; row < BOARD_SIZE; row++) {
		board[row] = [];
		cells[row] = [];
		for (var col = 0; col < BOARD_SIZE; col++) {
			board[row][col] = null;
			var cell = new Cell();
			cell.row = row;
			cell.col = col;
			cell.x = (col - 4.5) * cellSpacing;
			cell.y = (row - 4.5) * cellSpacing;
			boardContainer.addChild(cell);
			cells[row][col] = cell;
		}
	}
	// Create coordinate labels
	var cellSpacing = 1850 / BOARD_SIZE;
	for (var i = 0; i < BOARD_SIZE; i++) {
		// Column labels (A-J)
		var colLabel = new Text2(letters[i], {
			size: 40,
			fill: 0xFFFFFF
		});
		colLabel.anchor.set(0.5, 0.5);
		colLabel.x = (i - 4.5) * cellSpacing;
		colLabel.y = -945;
		boardContainer.addChild(colLabel);
		// Row labels (1-10)
		var rowLabel = new Text2((i + 1).toString(), {
			size: 40,
			fill: 0xFFFFFF
		});
		rowLabel.anchor.set(0.5, 0.5);
		rowLabel.x = -945;
		rowLabel.y = (i - 4.5) * cellSpacing;
		boardContainer.addChild(rowLabel);
	}
	// Create current player indicator
	playerText = new Text2('Current Player: Orange', {
		size: 60,
		fill: 0xFF8C00
	});
	playerText.anchor.set(0.5, 0);
	playerText.y = 100;
	LK.gui.top.addChild(playerText);
	// Create coordinates button
	coordButton = new CoordButton();
	coordButton.x = -100;
	coordButton.y = 100;
	LK.gui.topRight.addChild(coordButton);
	// Create history panel (initially hidden)
	historyPanel = new HistoryPanel();
	historyPanel.visible = false;
	game.addChild(historyPanel);
	historyPanel.x = 1024;
	historyPanel.y = 1366;
	// Initialize with starting pieces in center
	setupMode = true;
	placePiece(4, 4);
	placePiece(4, 5);
	placePiece(5, 5);
	placePiece(5, 4);
	setupMode = false;
	// Reset to orange player's turn
	currentPlayer = 0;
	updatePlayerText();
	updatePieceCounts();
}
// Game functions
function getCoordinate(row, col) {
	return letters[col] + (row + 1);
}
function placePiece(row, col) {
	if (!gameStarted || board[row][col] !== null) return;
	// Create and place piece
	var piece = new Piece();
	piece.setPlayer(currentPlayer);
	cells[row][col].addChild(piece);
	cells[row][col].piece = piece;
	board[row][col] = currentPlayer;
	// Play place sound
	LK.getSound('place').play();
	// Add to move history
	moveHistory.push({
		player: currentPlayer,
		coord: getCoordinate(row, col)
	});
	// Update history panel if visible
	if (historyVisible && historyPanel) {
		historyPanel.updateHistory();
	}
	// Check for flips in all directions
	var directions = [[-1, 0], [1, 0], [0, -1], [0, 1],
	// vertical and horizontal
	[-1, -1], [-1, 1], [1, -1], [1, 1] // diagonals
	];
	var totalFlips = 0;
	for (var d = 0; d < directions.length; d++) {
		var flips = checkDirection(row, col, directions[d][0], directions[d][1]);
		if (flips.length > 0) {
			flipPieces(flips);
			totalFlips += flips.length;
		}
	}
	if (totalFlips > 0) {
		LK.getSound('flip').play();
	}
	// Update piece counts
	updatePieceCounts();
	// Switch player
	currentPlayer = 1 - currentPlayer;
	updatePlayerText();
	// Check for game over
	checkGameOver();
	// If it's now grey's turn (AI), make AI move
	if (currentPlayer === 1 && !setupMode) {
		makeAIMove();
	}
}
function checkDirection(row, col, dRow, dCol) {
	var flips = [];
	var r = row + dRow;
	var c = col + dCol;
	// Find opponent pieces
	while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE) {
		if (board[r][c] === null) {
			return [];
		}
		if (board[r][c] === currentPlayer) {
			return flips;
		}
		flips.push([r, c]);
		r += dRow;
		c += dCol;
	}
	return [];
}
function flipPieces(positions) {
	for (var i = 0; i < positions.length; i++) {
		var row = positions[i][0];
		var col = positions[i][1];
		board[row][col] = currentPlayer;
		cells[row][col].piece.flip();
	}
}
function updatePlayerText() {
	var player = currentPlayer === 0 ? 'Orange' : 'Grey';
	var color = currentPlayer === 0 ? 0xff8c00 : 0x808080;
	playerText.setText('Current Player: ' + player);
	// Remove old text and create new one with updated color
	LK.gui.top.removeChild(playerText);
	playerText = new Text2('Current Player: ' + player, {
		size: 60,
		fill: color
	});
	playerText.anchor.set(0.5, 0);
	playerText.y = 100;
	LK.gui.top.addChild(playerText);
}
function updatePieceCounts() {
	var orangeCount = 0;
	var greyCount = 0;
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			if (board[row][col] === 0) {
				orangeCount++;
			} else if (board[row][col] === 1) {
				greyCount++;
			}
		}
	}
	orangeCountText.setText('Orange: ' + orangeCount);
	greyCountText.setText('Grey: ' + greyCount);
}
function checkGameOver() {
	// Don't check for game over during initial setup
	if (setupMode) return;
	var hasEmpty = false;
	var orangeCount = 0;
	var greyCount = 0;
	var hasValidMove = false;
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			if (board[row][col] === null) {
				hasEmpty = true;
				// Check if current player has valid move at this position
				if (!hasValidMove && isValidMove(row, col, currentPlayer)) {
					hasValidMove = true;
				}
			} else if (board[row][col] === 0) {
				orangeCount++;
			} else {
				greyCount++;
			}
		}
	}
	// Check for game over conditions
	if (!hasEmpty || !hasValidMove) {
		if (orangeCount > greyCount) {
			LK.showYouWin();
		} else {
			LK.showGameOver();
		}
	}
}
function toggleHistory() {
	historyVisible = !historyVisible;
	if (historyPanel) {
		historyPanel.visible = historyVisible;
		if (historyVisible) {
			historyPanel.updateHistory();
		}
	}
}
// AI functions
function isValidMove(row, col, player) {
	if (board[row][col] !== null) return false;
	var directions = [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [-1, 1], [1, -1], [1, 1]];
	for (var d = 0; d < directions.length; d++) {
		var flips = checkDirectionForPlayer(row, col, directions[d][0], directions[d][1], player);
		if (flips.length > 0) {
			return true;
		}
	}
	return false;
}
function checkDirectionForPlayer(row, col, dRow, dCol, player) {
	var flips = [];
	var r = row + dRow;
	var c = col + dCol;
	while (r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE) {
		if (board[r][c] === null) {
			return [];
		}
		if (board[r][c] === player) {
			return flips;
		}
		flips.push([r, c]);
		r += dRow;
		c += dCol;
	}
	return [];
}
function evaluateMove(row, col, player) {
	var directions = [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [-1, 1], [1, -1], [1, 1]];
	var totalFlips = 0;
	for (var d = 0; d < directions.length; d++) {
		var flips = checkDirectionForPlayer(row, col, directions[d][0], directions[d][1], player);
		totalFlips += flips.length;
	}
	// Easy AI: no strategic bonuses, just count flips
	return totalFlips;
}
function makeAIMove() {
	var validMoves = [];
	// Find all valid moves
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			if (isValidMove(row, col, 1)) {
				validMoves.push({
					row: row,
					col: col,
					score: evaluateMove(row, col, 1)
				});
			}
		}
	}
	if (validMoves.length > 0) {
		// Easy AI: pick randomly from moves that flip at least 1 piece
		// Filter out moves that don't flip any pieces
		var movesWithFlips = [];
		for (var i = 0; i < validMoves.length; i++) {
			if (validMoves[i].score > 0) {
				movesWithFlips.push(validMoves[i]);
			}
		}
		// If all moves flip pieces, use all valid moves
		if (movesWithFlips.length === 0) {
			movesWithFlips = validMoves;
		}
		// Pick a random move
		var randomIndex = Math.floor(Math.random() * movesWithFlips.length);
		var chosenMove = movesWithFlips[randomIndex];
		// Add small delay to make AI move visible
		LK.setTimeout(function () {
			placePiece(chosenMove.row, chosenMove.col);
		}, 500);
	}
}
;