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

/**** 
* Classes
****/ 
// DraggableBlock: Sürüklenebilir blok (ekranın altındaki bloklar)
var DraggableBlock = Container.expand(function () {
	var self = Container.call(this);
	self.shapeIndex = 0; // BLOCK_SHAPES indexi
	self.matrix = null; // 2D array
	self.asset = null; // asset adı
	self.cells = []; // Çocuk bloklar (Container)
	self.isDragging = false;
	self.dragOffsetX = 0;
	self.dragOffsetY = 0;
	self.originX = 0;
	self.originY = 0;
	// Blok oluştur
	self.init = function (shapeIndex) {
		self.shapeIndex = shapeIndex;
		var shape = BLOCK_SHAPES[shapeIndex];
		self.matrix = shape.matrix;
		self.asset = shape.asset;
		// Önceki hücreleri temizle
		for (var i = 0; i < self.cells.length; i++) {
			self.cells[i].destroy();
		}
		self.cells = [];
		// Blok hücrelerini oluştur
		var rows = self.matrix.length;
		var cols = self.matrix[0].length;
		for (var r = 0; r < rows; r++) {
			for (var c = 0; c < cols; c++) {
				if (self.matrix[r][c]) {
					var cell = new Container();
					var asset = cell.attachAsset(self.asset, {
						anchorX: 0.5,
						anchorY: 0.5
					});
					cell.x = c * GRID_CELL_SIZE;
					cell.y = r * GRID_CELL_SIZE;
					self.addChild(cell);
					self.cells.push(cell);
				}
			}
		}
		// Blokun merkezini anchor olarak ayarla
		self.pivot.x = (cols - 1) * GRID_CELL_SIZE / 2;
		self.pivot.y = (rows - 1) * GRID_CELL_SIZE / 2;
		self.width = cols * GRID_CELL_SIZE;
		self.height = rows * GRID_CELL_SIZE;
	};
	// Sürükleme başlat
	self.startDrag = function (x, y) {
		self.isDragging = true;
		self.dragOffsetX = x - self.x;
		self.dragOffsetY = y - self.y;
		self.originX = self.x;
		self.originY = self.y;
		// Öne getir
		if (self.parent) {
			self.parent.setChildIndex(self, self.parent.children.length - 1);
		}
		// Hafif büyüt
		tween(self, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 120,
			easing: tween.easeOut
		});
	};
	// Sürükleme bitir
	self.stopDrag = function () {
		self.isDragging = false;
		tween(self, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 120,
			easing: tween.easeIn
		});
	};
	// Sürükleme sırasında pozisyon güncelle
	self.dragMove = function (x, y) {
		if (self.isDragging) {
			self.x = x - self.dragOffsetX;
			self.y = y - self.dragOffsetY;
		}
	};
	// Orijinal konuma dön
	self.returnToOrigin = function () {
		tween(self, {
			x: self.originX,
			y: self.originY
		}, {
			duration: 180,
			easing: tween.easeIn
		});
	};
	return self;
});
/**** 
* Oyun Sabitleri
****/ 
// GridCell: Izgara hücresi (arka plan için)
var GridCell = Container.expand(function () {
	var self = Container.call(this);
	var cell = self.attachAsset('gridCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// PlacedBlock: Izgaraya yerleştirilen blokun bir parçası
var PlacedBlock = Container.expand(function () {
	var self = Container.call(this);
	// asset ve renk, parametre olarak alınacak
	self.init = function (asset) {
		self.asset = self.attachAsset(asset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Blokların gösterileceği alt kısım
var game = new LK.Game({
	backgroundColor: 0x181c22
});

/**** 
* Game Code
****/ 
// Her şekil: {matrix: 2D array, asset: string}
/**** 
* Blok Şekilleri Tanımı
****/ 
// Blok şekilleri için renkli kutular ve ızgara hücreleri
// Izgara verisi: 10x10, 0=boş, 1=dolu
var BLOCK_SHAPES = [
// Tekli blok
{
	matrix: [[1]],
	asset: 'block1'
},
// 1x2 yatay
{
	matrix: [[1, 1]],
	asset: 'block2'
},
// 1x3 yatay
{
	matrix: [[1, 1, 1]],
	asset: 'block3'
},
// 2x1 dikey
{
	matrix: [[1], [1]],
	asset: 'block4'
},
// 3x1 dikey
{
	matrix: [[1], [1], [1]],
	asset: 'block5'
},
// 2x2 kare
{
	matrix: [[1, 1], [1, 1]],
	asset: 'block6'
},
// L şekli
{
	matrix: [[1, 0], [1, 0], [1, 1]],
	asset: 'block7'
},
// T şekli
{
	matrix: [[1, 1, 1], [0, 1, 0]],
	asset: 'block2'
},
// Z şekli
{
	matrix: [[1, 1, 0], [0, 1, 1]],
	asset: 'block3'
},
// 1x4 yatay
{
	matrix: [[1, 1, 1, 1]],
	asset: 'block4'
},
// 4x1 dikey
{
	matrix: [[1], [1], [1], [1]],
	asset: 'block5'
}];
/**** 
* Oyun Sabitleri
****/ 
var GRID_SIZE = 10;
var GRID_CELL_SIZE = 180; // px
var GRID_MARGIN_TOP = 180; // px
var GRID_MARGIN_LEFT = 124; // px (2048-1800)/2
var BLOCK_AREA_Y = 2200;
var grid = [];
for (var i = 0; i < GRID_SIZE; i++) {
	grid[i] = [];
	for (var j = 0; j < GRID_SIZE; j++) {
		grid[i][j] = 0;
	}
}
// Izgara hücrelerini çiz
var gridCells = [];
var gridOverlayCells = [];
for (var r = 0; r < GRID_SIZE; r++) {
	for (var c = 0; c < GRID_SIZE; c++) {
		var cell = new GridCell();
		cell.x = GRID_MARGIN_LEFT + c * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		cell.y = GRID_MARGIN_TOP + r * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		game.addChild(cell);
		gridCells.push(cell);
		// Küçük overlay hücresi (gri, daha küçük, üstte)
		var overlay = new Container();
		var overlayAsset = overlay.attachAsset('gridCell', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: GRID_CELL_SIZE * 0.28,
			height: GRID_CELL_SIZE * 0.28,
			color: 0x444c5a
		});
		overlay.x = cell.x;
		overlay.y = cell.y;
		overlay.alpha = 0.7;
		game.addChild(overlay);
		gridOverlayCells.push(overlay);
	}
}
// Skor göstergesi
var score = 0;
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Sürüklenebilir bloklar (en fazla 3 blok)
var draggableBlocks = [];
var BLOCKS_PER_SET = 3;
// Blokları oluştur ve konumlandır
function spawnDraggableBlocks() {
	// Öncekileri temizle
	for (var i = 0; i < draggableBlocks.length; i++) {
		draggableBlocks[i].destroy();
	}
	draggableBlocks = [];
	for (var i = 0; i < BLOCKS_PER_SET; i++) {
		var block = new DraggableBlock();
		var shapeIndex = Math.floor(Math.random() * BLOCK_SHAPES.length);
		block.init(shapeIndex);
		// Blokları alt kısımda ortalı ve aralıklı yerleştir
		var totalWidth = BLOCKS_PER_SET * 360 + (BLOCKS_PER_SET - 1) * 60;
		var startX = (2048 - totalWidth) / 2 + 180;
		block.x = startX + i * (360 + 60);
		block.y = BLOCK_AREA_Y;
		block.scaleX = 1;
		block.scaleY = 1;
		game.addChild(block);
		draggableBlocks.push(block);
	}
}
// Izgaraya blok yerleştirilebilir mi? (pozisyon, şekil matrisi)
function canPlaceBlockAt(row, col, matrix) {
	var rows = matrix.length;
	var cols = matrix[0].length;
	if (row + rows > GRID_SIZE || col + cols > GRID_SIZE) return false;
	for (var r = 0; r < rows; r++) {
		for (var c = 0; c < cols; c++) {
			if (matrix[r][c]) {
				if (grid[row + r][col + c]) return false;
			}
		}
	}
	return true;
}
// Blok yerleştir (verilen pozisyon ve şekil)
function placeBlockAt(row, col, matrix, asset) {
	var rows = matrix.length;
	var cols = matrix[0].length;
	for (var r = 0; r < rows; r++) {
		for (var c = 0; c < cols; c++) {
			if (matrix[r][c]) {
				grid[row + r][col + c] = 1;
				// Görsel olarak ekle
				var pb = new PlacedBlock();
				pb.init(asset);
				pb.x = GRID_MARGIN_LEFT + (col + c) * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
				pb.y = GRID_MARGIN_TOP + (row + r) * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
				game.addChild(pb);
			}
		}
	}
}
// Satır/sütun temizle ve skor ekle
function clearFullLines() {
	var cleared = 0;
	// Satırları kontrol et
	for (var r = 0; r < GRID_SIZE; r++) {
		var full = true;
		for (var c = 0; c < GRID_SIZE; c++) {
			if (!grid[r][c]) {
				full = false;
				break;
			}
		}
		if (full) {
			cleared++;
			for (var c = 0; c < GRID_SIZE; c++) {
				grid[r][c] = 0;
				// O hücredeki placedblock'u bul ve yok et
				removePlacedBlockAt(r, c);
			}
		}
	}
	// Sütunları kontrol et
	for (var c = 0; c < GRID_SIZE; c++) {
		var full = true;
		for (var r = 0; r < GRID_SIZE; r++) {
			if (!grid[r][c]) {
				full = false;
				break;
			}
		}
		if (full) {
			cleared++;
			for (var r = 0; r < GRID_SIZE; r++) {
				grid[r][c] = 0;
				removePlacedBlockAt(r, c);
			}
		}
	}
	if (cleared > 0) {
		score += cleared * 10;
		scoreTxt.setText(score);
		LK.effects.flashObject(scoreTxt, 0xffff00, 400);
	}
}
// Izgaradaki bir hücredeki placedblock'u bul ve yok et
function removePlacedBlockAt(row, col) {
	var x = GRID_MARGIN_LEFT + col * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
	var y = GRID_MARGIN_TOP + row * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
	// game.children içinde arama
	for (var i = game.children.length - 1; i >= 0; i--) {
		var obj = game.children[i];
		if (obj instanceof PlacedBlock) {
			if (Math.abs(obj.x - x) < 2 && Math.abs(obj.y - y) < 2) {
				obj.destroy();
				break;
			}
		}
	}
}
// Ekrandaki bloklardan biri ızgaraya yerleştirilebiliyor mu?
function anyBlockFits() {
	for (var i = 0; i < draggableBlocks.length; i++) {
		var block = draggableBlocks[i];
		if (!block.parent) continue; // Kullanılmış blok
		var matrix = block.matrix;
		var rows = matrix.length;
		var cols = matrix[0].length;
		for (var r = 0; r <= GRID_SIZE - rows; r++) {
			for (var c = 0; c <= GRID_SIZE - cols; c++) {
				if (canPlaceBlockAt(r, c, matrix)) return true;
			}
		}
	}
	return false;
}
// Bloklar bittiğinde yeni set oluştur
function allBlocksUsed() {
	for (var i = 0; i < draggableBlocks.length; i++) {
		if (draggableBlocks[i].parent) return false;
	}
	return true;
}
// Sürükleme değişkenleri
var draggingBlock = null;
// Oyun başlat
score = 0;
scoreTxt.setText(score);
var gameOverTriggered = false;
spawnDraggableBlocks();
// Oyun hareketleri
game.move = function (x, y, obj) {
	// Sürüklenen blok varsa, hareket ettir
	if (draggingBlock) {
		draggingBlock.dragMove(x, y);
		// Vurgulama: Blokun ızgarada uygun yere denk gelip gelmediğini kontrol et
		var block = draggingBlock;
		var matrix = block.matrix;
		var rows = matrix.length;
		var cols = matrix[0].length;
		var gridX = Math.round((block.x + block.pivot.x - GRID_MARGIN_LEFT - GRID_CELL_SIZE / 2) / GRID_CELL_SIZE);
		var gridY = Math.round((block.y + block.pivot.y - GRID_MARGIN_TOP - GRID_CELL_SIZE / 2) / GRID_CELL_SIZE);
		// Tüm grid hücrelerinin rengini sıfırla
		for (var i = 0; i < gridCells.length; i++) {
			gridCells[i].alpha = 1;
		}
		// Eğer uygun yere denk geliyorsa, ilgili hücreleri vurgula
		if (canPlaceBlockAt(gridY, gridX, matrix)) {
			for (var r = 0; r < rows; r++) {
				for (var c = 0; c < cols; c++) {
					if (matrix[r][c]) {
						var idx = (gridY + r) * GRID_SIZE + (gridX + c);
						if (idx >= 0 && idx < gridCells.length) {
							gridCells[idx].alpha = 0.6;
						}
					}
				}
			}
		}
	}
};
game.down = function (x, y, obj) {
	// Bloklardan birine tıklandı mı?
	for (var i = 0; i < draggableBlocks.length; i++) {
		var block = draggableBlocks[i];
		if (!block.parent) continue;
		// Blok sınırları içinde mi?
		var local = block.toLocal(game.toGlobal({
			x: x,
			y: y
		}));
		// Blokun alanı içinde mi?
		if (local.x >= -block.pivot.x && local.x <= block.width - block.pivot.x && local.y >= -block.pivot.y && local.y <= block.height - block.pivot.y) {
			draggingBlock = block;
			block.startDrag(x, y);
			break;
		}
	}
};
game.up = function (x, y, obj) {
	if (!draggingBlock) return;
	// Grid hücrelerinin vurgusunu sıfırla
	for (var i = 0; i < gridCells.length; i++) {
		gridCells[i].alpha = 1;
	}
	// Bırakılan pozisyonu ızgaraya çevir
	var block = draggingBlock;
	var matrix = block.matrix;
	var rows = matrix.length;
	var cols = matrix[0].length;
	// Blokun merkezini referans al
	var gridX = Math.round((block.x + block.pivot.x - GRID_MARGIN_LEFT - GRID_CELL_SIZE / 2) / GRID_CELL_SIZE);
	var gridY = Math.round((block.y + block.pivot.y - GRID_MARGIN_TOP - GRID_CELL_SIZE / 2) / GRID_CELL_SIZE);
	// Eğer blokun bir kısmı grid dışına taşarsa veya yerleşemezse, yerleştirme yapılmaz
	if (gridX >= 0 && gridY >= 0 && gridX + cols <= GRID_SIZE && gridY + rows <= GRID_SIZE && canPlaceBlockAt(gridY, gridX, matrix)) {
		// Yerleştir
		placeBlockAt(gridY, gridX, matrix, block.asset);
		block.destroy();
		draggingBlock = null;
		clearFullLines();
		// Tüm bloklar kullanıldıysa yeni set oluştur
		if (allBlocksUsed()) {
			spawnDraggableBlocks();
		}
		// Oyun bitti mi?
		if (!anyBlockFits()) {
			LK.effects.flashScreen(0xff0000, 800);
			LK.showGameOver();
		}
	} else {
		// Yerleştirilemezse orijinal konuma dön
		block.returnToOrigin();
		block.stopDrag();
		draggingBlock = null;
	}
};
// Oyun güncellemesi (gerektiğinde)
var gameOverTriggered = false;
game.update = function () {
	// Oyun bitti mi? (her frame kontrol)
	if (!anyBlockFits() && !gameOverTriggered) {
		gameOverTriggered = true;
		LK.effects.flashScreen(0xff0000, 800);
		LK.showGameOver();
	}
};