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

/**** 
* Classes
****/ 
var Chef = Container.expand(function () {
	var self = Container.call(this);
	var chefGraphics = self.attachAsset('chef', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.cooking = false;
	self.cookTime = 0;
	self.currentFoodType = -1; // Track which food type is being cooked
	self.targetTableIndex = -1; // Track which table the food is for
	self.update = function () {
		if (chefHasOrder && !self.cooking && !foodReady) {
			self.cooking = true;
			self.cookTime = 0;
			self.currentFoodType = currentOrderFoodType; // Remember which food to cook
			self.targetTableIndex = currentOrderTableIndex; // Remember which table it's for
			// Log which table number's order is being cooked
			if (self.targetTableIndex >= 0 && self.targetTableIndex < tables.length) {
				console.log('Chef cooking for table number: ' + tables[self.targetTableIndex].tableNumber);
			}
			chefHasOrder = false;
		}
		if (self.cooking) {
			self.cookTime++;
			if (self.cookTime > cookingSpeed) {
				self.cooking = false;
				foodReady = true;
				// Pass cooked food info back through globals
				currentOrderFoodType = self.currentFoodType;
				currentOrderTableIndex = self.targetTableIndex;
				// Reset order taken for the specific table
				if (self.targetTableIndex >= 0 && self.targetTableIndex < orderTaken.length) {
					orderTaken[self.targetTableIndex] = false;
				}
			}
		}
	};
	return self;
});
var Customer = Container.expand(function () {
	var self = Container.call(this);
	// Pick a random customer image from 10 options
	var customerImageIds = ['customer1', 'customer2', 'customer3', 'customer4', 'customer5', 'customer6', 'customer7', 'customer8', 'customer9', 'customer10'];
	self.customerImageId = customerImageIds[Math.floor(Math.random() * customerImageIds.length)];
	var customerGraphics = self.attachAsset(self.customerImageId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetTable = null;
	self.targetTableIndex = -1; // Track which table index is reserved
	self.state = 'entering'; // entering, seated, waiting, eating, paying, leaving
	self.eatingTime = 0;
	self.waitTime = 0;
	self.foodType = Math.floor(Math.random() * foodTypes.length); // Random food type
	self.update = function () {
		if (self.state === 'entering') {
			if (self.targetTable) {
				// Only allow sitting if table is not occupied and no customer is still at the table
				if (!self.targetTable.occupied && !self.targetTable.customer) {
					var dx = self.targetTable.x - self.x;
					var dy = self.targetTable.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist > 5) {
						self.x += dx / dist * customerSpeed;
						self.y += dy / dist * customerSpeed;
					} else {
						self.state = 'seated';
						self.targetTable.occupied = true;
						self.targetTable.customer = self;
					}
				} else {
					// Table is not available, clear assignment and wait
					self.targetTable = null;
					self.targetTableIndex = -1;
				}
			} else {
				// Wait in line near exit (register) if no table available
				// Move downwards from the register position (registerY)
				if (self.y < registerY + 200) {
					self.y += customerSpeed;
				}
			}
		} else if (self.state === 'eating') {
			// Do not show food image above customer; only show food on table when delivered
			self.eatingTime++;
			if (self.eatingTime > 180) {
				// 3 seconds at 60fps
				self.state = 'paying';
				// No food image above customer to remove
				if (self.targetTable) {
					self.targetTable.foodDelivered = false;
					if (self.targetTable.food) {
						self.targetTable.food.destroy();
						self.targetTable.food = null;
					}
				}
			}
		} else if (self.state === 'paying') {
			var dx = registerX - self.x;
			var dy = registerY - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * customerSpeed;
				self.y += dy / dist * customerSpeed;
			} else {
				// Add money based on food type price
				money += foodPrices[self.foodType];
				// Update last sold food info
				lastSoldFoodName = foodNames[self.foodType];
				lastSoldFoodPrice = foodPrices[self.foodType];
				// Increment food sales count
				if (typeof foodSales !== "undefined" && self.foodType >= 0 && self.foodType < foodSales.length) {
					foodSales[self.foodType]++;
				}
				self.state = 'leaving';
				if (self.targetTable) {
					self.targetTable.occupied = false;
					self.targetTable.customer = null;
					self.targetTable.orderPlaced = false;
					self.targetTable.orderedFoodType = -1; // Reset food type
				}
				// Clear reservation
				if (self.targetTableIndex >= 0) {
					tableReservations[self.targetTableIndex] = false;
				}
			}
		} else if (self.state === 'leaving') {
			self.y += customerSpeed;
			if (self.y > 2800) {
				// Clear reservation before destroying
				if (self.targetTableIndex >= 0) {
					tableReservations[self.targetTableIndex] = false;
				}
				// Clean up food on table if still present
				if (self.targetTable && self.targetTable.food) {
					self.targetTable.food.destroy();
					self.targetTable.food = null;
					self.targetTable.foodDelivered = false;
					self.targetTable.orderPlaced = false;
					self.targetTable.orderedFoodType = -1;
				}
				self.destroy();
				var index = customers.indexOf(self);
				if (index > -1) customers.splice(index, 1);
			}
		} else if (self.state === 'seated') {
			self.waitTime++;
			if (self.waitTime > 120) {
				// 2 seconds
				self.targetTable.orderPlaced = true;
				self.targetTable.orderedFoodType = self.foodType; // Set the food type on table
				self.state = 'waiting';
			}
		}
	};
	return self;
});
var Table = Container.expand(function () {
	var self = Container.call(this);
	var tableGraphics = self.attachAsset('table', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var chair = self.attachAsset('chair', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 60
	});
	self.occupied = false;
	self.customer = null;
	self.food = null;
	self.orderPlaced = false;
	self.foodDelivered = false;
	self.orderedFoodType = -1; // Store which food type was ordered
	self.tableNumber = -1; // Table number for tracking
	// Create table number text
	self.numberText = new Text2('', {
		size: 50,
		fill: 0xFFFFFF,
		font: "'GillSans',Impact,'Arial Black',Tahoma" // Remove bold font
	});
	self.numberText.anchor.set(0.5, 0.5);
	self.addChild(self.numberText);
	// Method to set table number
	self.setTableNumber = function (number) {
		self.tableNumber = number;
		self.numberText.setText('' + number);
	};
	return self;
});
var Waiter = Container.expand(function () {
	var self = Container.call(this);
	var waiterGraphics = self.attachAsset('waiter', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.state = 'idle'; // idle, goingToTable, goingToKitchen, deliveringFood
	self.targetTable = null;
	self.hasFood = false;
	self.food = null;
	self.carryingFoodType = -1; // Track which food type waiter is carrying
	self.targetTableIndex = -1; // Track which table the order/food is for
	self.servingTableIndex = -1; // Track which table is being served until order is complete
	self.update = function () {
		if (self.state === 'idle') {
			// If currently serving a table, check for ready food for that table
			if (self.servingTableIndex >= 0 && foodReady && !foodBeingDelivered && currentOrderTableIndex === self.servingTableIndex) {
				self.state = 'goingToKitchen';
			} else if (self.servingTableIndex < 0) {
				// Only take new orders when not serving any table
				// Find the first table with an order that is not being served
				var foundTable = false;
				for (var i = 0; i < tables.length; i++) {
					// Check if any other waiter is already serving this table
					var beingServed = false;
					// Check main waiter
					if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
					// Check extra waiters
					if (typeof game !== "undefined" && game.extraWaiters) {
						for (var w = 0; w < game.extraWaiters.length; w++) {
							if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
								beingServed = true;
								break;
							}
						}
					}
					// Only serve table if not being served by any waiter, and not already assigned to another waiter
					if (tables[i].orderPlaced && !orderTaken[i] && !beingServed && (self.servingTableIndex === -1 || self.servingTableIndex !== i)) {
						self.state = 'goingToTable';
						self.targetTable = tables[i];
						self.targetTableIndex = i;
						self.servingTableIndex = i; // Start serving this table
						// Log which table number is being served
						console.log('Waiter serving table number: ' + tables[i].tableNumber);
						foundTable = true;
						break;
					}
				}
				// If no table found, remain idle, but do not allow waiter to be idle if there are waiting orders
				if (!foundTable) {
					// Check if there are any tables with orderPlaced and not being served
					for (var i = 0; i < tables.length; i++) {
						var beingServed = false;
						if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
						if (typeof game !== "undefined" && game.extraWaiters) {
							for (var w = 0; w < game.extraWaiters.length; w++) {
								if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
									beingServed = true;
									break;
								}
							}
						}
						if (tables[i].orderPlaced && !orderTaken[i] && !beingServed) {
							// Assign this waiter to this table
							self.state = 'goingToTable';
							self.targetTable = tables[i];
							self.targetTableIndex = i;
							self.servingTableIndex = i;
							break;
						}
					}
				}
			}
		} else if (self.state === 'goingToTable') {
			var dx = self.targetTable.x - self.x;
			var dy = self.targetTable.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				orderTaken[self.targetTableIndex] = true;
				self.carryingFoodType = self.targetTable.orderedFoodType; // Remember the food type
				// Pass order details to chef through global variables
				currentOrderFoodType = self.carryingFoodType;
				currentOrderTableIndex = self.targetTableIndex;
				chefHasOrder = true;
				self.state = 'goingToKitchen';
			}
		} else if (self.state === 'goingToKitchen') {
			var dx = kitchenX - self.x;
			var dy = kitchenY - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				// Check if food is ready for pickup
				if (foodReady && !self.hasFood && currentOrderTableIndex === self.servingTableIndex) {
					self.hasFood = true;
					foodReady = false;
					foodBeingDelivered = true;
					self.carryingFoodType = currentOrderFoodType; // Remember which food type
					self.targetTableIndex = currentOrderTableIndex; // Remember target table
					self.food = self.attachAsset(foodImageIds[self.carryingFoodType], {
						anchorX: 0.5,
						anchorY: 0.5,
						y: -40
					});
					// Deliver to the specific table that ordered this food
					if (self.targetTableIndex >= 0 && self.targetTableIndex < tables.length) {
						self.targetTable = tables[self.targetTableIndex];
						self.state = 'deliveringFood';
					}
				} else {
					// If not serving any table and not carrying food, reset to idle so waiter doesn't get stuck at kitchen
					if (!self.hasFood && (self.servingTableIndex === -1 || typeof self.servingTableIndex === "undefined")) {
						self.state = 'idle';
						self.targetTable = null;
						self.targetTableIndex = -1;
					}
				}
				// Stay at kitchen waiting for food - don't go back to idle unless above
			}
		} else if (self.state === 'deliveringFood') {
			var dx = self.targetTable.x - self.x;
			var dy = self.targetTable.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				if (self.food) {
					self.food.destroy();
					self.food = null;
				}
				self.hasFood = false;
				foodBeingDelivered = false;
				// Mark food delivered and reset order state so waiter doesn't deliver again
				self.targetTable.foodDelivered = true;
				self.targetTable.food = self.targetTable.attachAsset(foodImageIds[self.carryingFoodType], {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -20
				});
				self.targetTable.orderPlaced = false; // Reset orderPlaced so waiter doesn't deliver again
				orderTaken[self.targetTableIndex] = false; // Reset orderTaken for this table
				self.targetTable.orderedFoodType = -1; // Reset food type for this table
				if (self.targetTable.customer) {
					self.targetTable.customer.state = 'eating';
				}
				self.servingTableIndex = -1; // Order complete, can serve another table
				self.targetTable = null;
				// Always immediately pick up next waiting order if available
				var foundNextTable = false;
				for (var i = 0; i < tables.length; i++) {
					// Check if any other waiter is already serving this table
					var beingServed = false;
					if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
					if (typeof game !== "undefined" && game.extraWaiters) {
						for (var w = 0; w < game.extraWaiters.length; w++) {
							if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
								beingServed = true;
								break;
							}
						}
					}
					// Only serve table if not being served by any waiter, and not already assigned to another waiter
					if (tables[i].orderPlaced && !orderTaken[i] && !beingServed && (self.servingTableIndex === -1 || self.servingTableIndex !== i)) {
						self.state = 'goingToTable';
						self.targetTable = tables[i];
						self.targetTableIndex = i;
						self.servingTableIndex = i; // Start serving this table
						console.log('Waiter immediately serving next table number: ' + tables[i].tableNumber);
						foundNextTable = true;
						break;
					}
				}
				if (!foundNextTable) {
					// If there are still waiting orders, do not allow waiter to be idle
					for (var i = 0; i < tables.length; i++) {
						var beingServed = false;
						if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
						if (typeof game !== "undefined" && game.extraWaiters) {
							for (var w = 0; w < game.extraWaiters.length; w++) {
								if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
									beingServed = true;
									break;
								}
							}
						}
						if (tables[i].orderPlaced && !orderTaken[i] && !beingServed) {
							self.state = 'goingToTable';
							self.targetTable = tables[i];
							self.targetTableIndex = i;
							self.servingTableIndex = i;
							break;
						}
					}
					if (self.state !== 'goingToTable') {
						self.state = 'idle';
					}
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Add main menu background image (covers full game area)
var mainMenuBg = game.addChild(LK.getAsset('mainMenuBg', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	width: 2048,
	height: 2732
}));
// Game variables
// Food image assets (replace with your own images as needed)
var money = typeof storage.money !== "undefined" ? storage.money : 1000;
var restaurantLevel = storage.restaurantLevel || 1;
var tableCount = storage.tableCount || 2;
var tableReservations = []; // Track which tables are reserved by customers
// Food types
var foodTypes = ['pizza', 'burger', 'pasta', 'salad', 'soup', 'sushi', 'steak', 'curry', 'taco', 'dumpling'];
var foodNames = ['Pizza', 'Burger', 'Pasta', 'Salad', 'Soup', 'Sushi', 'Steak', 'Curry', 'Taco', 'Dumpling'];
var foodImageIds = ['food_pizza', 'food_burger', 'food_pasta', 'food_salad', 'food_soup', 'food_sushi', 'food_steak', 'food_curry', 'food_taco', 'food_dumpling'];
var foodColors = [0xff6347, 0x8b4513, 0xffa500, 0x32cd32, 0xffd700, 0x6ad1e3, 0x8b0000, 0xf7b32b, 0xf4a259, 0xf7e7ce];
// Food prices: multiples of 6, each next is 10% more (rounded to nearest integer)
var foodPrices = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; // Will be set below
// Calculate food prices as 6, 6*1.1, 6*1.21, ... for all foodTypes (rounded)
foodPrices[0] = 6;
for (var i = 1; i < foodTypes.length; i++) {
	foodPrices[i] = Math.round(foodPrices[i - 1] * 1.1);
}
// Speed variables (lower is faster)
var customerSpeed = 3;
var waiterSpeed = 4;
var cookingSpeed = 180; // 3 seconds at 60fps
// Game state
var tables = [];
var customers = [];
var orderTaken = [];
var chefHasOrder = false;
var foodReady = false;
var foodBeingDelivered = false;
var currentOrderFoodType = -1; // Track current order food type
var currentOrderTableIndex = -1; // Track current order table index
// Positions
var kitchenX = 1024;
var kitchenY = 400;
var registerX = 1024;
var registerY = 2400;
// UI Elements
var moneyText = new Text2('Money: $0', {
	size: 36,
	fill: 0xFFFFFF,
	font: "'GillSans',Tahoma" // Remove bold font
});
moneyText.anchor.set(0.5, 0);
LK.gui.top.addChild(moneyText);
// --- Reset Game Button (to the left of the coin) ---
var resetButton = new Text2('Reset', {
	size: 48,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 140
});
resetButton.anchor.set(1, 0); // right-top anchor
resetButton.x = moneyText.x - 180 - 2048 * 0.05; // Move 5% of screen width further left
resetButton.y = moneyText.y + 8; // Align vertically with moneyText
resetButton.interactive = true;
resetButton.buttonMode = true;
resetButton.down = function () {
	// Reset all purchases, upgrades, and research to initial values before game over
	storage.money = 1000;
	storage.restaurantLevel = 1;
	storage.tableCount = 2;
	storage.upgradeSpeedLevel = 0;
	storage.upgradeSpeedCost = 50;
	storage.advertisementLevel = 0;
	storage.customerSpeedLevel = 0;
	storage.customerSpeedCost = 50;
	// Clear any other persistent research/progress
	// Optionally clear food sales and other stats if stored
	LK.showGameOver(); // This will reset the game state
};
LK.gui.top.addChild(resetButton);
// --- Last sold food info (top right) ---
var lastSoldFoodName = '';
var lastSoldFoodPrice = 0;
var lastSoldText = new Text2('', {
	size: 48,
	fill: 0xFFFFFF,
	font: "'GillSans',Tahoma" // Remove bold font
});
lastSoldText.anchor.set(1, 0); // right-top
LK.gui.topRight.addChild(lastSoldText);
// --- Top 5 Most Sold Foods Panel (below Son Satış) ---
var foodSales = [];
for (var i = 0; i < foodTypes.length; i++) {
	foodSales[i] = 0;
}
// Panel background image for Top 5 Most Sold Foods
var top5PanelBg = LK.getAsset('top5PanelBg', {
	anchorX: 1,
	anchorY: 0,
	x: 2048,
	y: 120,
	width: 500,
	height: 385 // 350 * 1.1 = 385
});
top5PanelBg.alpha = 0.92;
game.addChild(top5PanelBg);
var top5Title = new Text2('TOP 5', {
	size: 40,
	fill: 0xFFFFFF,
	font: "'GillSans',Tahoma" // Remove bold font
});
// Anchor left-top
top5Title.anchor.set(0, 0);
// Align to left edge of the panel (panel x = 2048, width = 500)
top5Title.x = 2048 - 500 + 20;
top5Title.y = 140;
game.addChild(top5Title);
var top5TextLines = [];
for (var i = 0; i < 5; i++) {
	var txt = new Text2('', {
		size: 36,
		fill: 0xFFFFFF,
		font: "'GillSans',Tahoma" // Remove bold font
	});
	// Anchor left-top
	txt.anchor.set(0, 0);
	// Align to left edge of the panel (panel x = 2048, width = 500)
	txt.x = 2048 - 500 + 20;
	txt.y = 200 + i * 55;
	game.addChild(txt);
	top5TextLines.push(txt);
}
// Create kitchen
var kitchen = game.addChild(LK.getAsset('kitchen', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: kitchenX,
	y: kitchenY
}));
// Create register
var register = game.addChild(LK.getAsset('register', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: registerX,
	y: registerY
}));
// Create chef
var chef = game.addChild(new Chef());
chef.x = kitchenX;
chef.y = kitchenY;
// Create waiter
var waiter = game.addChild(new Waiter());
// Spawn main waiter in front of the register (kasa)
waiter.x = registerX - 120;
waiter.y = registerY + 60;
// Always initialize extraWaiters as an array so new waiters can be added and updated
game.extraWaiters = [];
// Create initial tables
function createTable(index) {
	var table = game.addChild(new Table());
	// Arrange tables in rows of 5
	var row = Math.floor(index / 5);
	var col = index % 5;
	table.x = 300 + col * 300;
	table.y = 800 + row * 300;
	table.setTableNumber(index + 1); // Set table number (1-based)
	tables.push(table);
	orderTaken.push(false);
	tableReservations.push(false); // Initialize reservation status
}
for (var i = 0; i < tableCount; i++) {
	createTable(i);
}
// Upgrade speed button
var upgradeButton = game.addChild(LK.getAsset('upgradeButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 500,
	y: 2200
}));
var upgradeText = new Text2('Upgrade Speed $50', {
	size: 36,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 260
});
upgradeText.anchor.set(0.5, 0.5);
upgradeText.x = 500;
upgradeText.y = 2200;
game.addChild(upgradeText);
// Track upgrade cost and max level
var upgradeSpeedLevel = typeof storage.upgradeSpeedLevel !== "undefined" ? storage.upgradeSpeedLevel : 0;
var upgradeSpeedCost = typeof storage.upgradeSpeedCost !== "undefined" ? storage.upgradeSpeedCost : 50;
var UPGRADE_SPEED_MAX_LEVEL = 5;
function updateUpgradeText() {
	if (upgradeSpeedLevel >= UPGRADE_SPEED_MAX_LEVEL) {
		upgradeText.setText('Upgrade Speed (MAX)');
	} else {
		upgradeText.setText('Upgrade Speed $' + upgradeSpeedCost);
	}
}
upgradeButton.down = function () {
	if (upgradeSpeedLevel < UPGRADE_SPEED_MAX_LEVEL && money >= upgradeSpeedCost) {
		money -= upgradeSpeedCost;
		upgradeSpeedLevel++;
		upgradeSpeedCost = upgradeSpeedCost * 2;
		restaurantLevel++;
		customerSpeed = Math.max(2, customerSpeed - 0.5);
		waiterSpeed = waiterSpeed * 1.1;
		cookingSpeed = Math.max(60, cookingSpeed - 20);
		storage.restaurantLevel = restaurantLevel;
		storage.money = money;
		storage.upgradeSpeedLevel = upgradeSpeedLevel;
		storage.upgradeSpeedCost = upgradeSpeedCost;
		LK.effects.flashObject(upgradeButton, 0x00FF00, 500);
		updateUpgradeText();
	}
};
updateUpgradeText();
// --- Advertisement Upgrade Button below Upgrade Speed ---
var advertisementLevel = typeof storage.advertisementLevel !== "undefined" ? storage.advertisementLevel : 0;
var advertisementButton = game.addChild(LK.getAsset('upgradeButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 500,
	y: 2280
}));
var advertisementText = new Text2('Advertisement $100', {
	size: 36,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 260
});
advertisementText.anchor.set(0.5, 0.5);
advertisementText.x = 500;
advertisementText.y = 2280;
game.addChild(advertisementText);
// Track advertisement upgrade cost, default to 100 * (advertisementLevel+1)
var advertisementCost = typeof storage.advertisementCost !== "undefined" ? storage.advertisementCost : 100 * (advertisementLevel + 1);
function updateAdvertisementText() {
	advertisementText.setText('Advertisement $' + advertisementCost);
}
advertisementButton.down = function () {
	if (money >= advertisementCost) {
		money -= advertisementCost;
		advertisementLevel++;
		advertisementCost = 100 * (advertisementLevel + 1);
		storage.advertisementLevel = advertisementLevel;
		storage.advertisementCost = advertisementCost;
		storage.money = money;
		LK.effects.flashObject(advertisementButton, 0x00FF00, 500);
		updateAdvertisementText();
	}
};
updateAdvertisementText();
// --- Customer Speed Upgrade Button below Advertisement ---
var customerSpeedLevel = typeof storage.customerSpeedLevel !== "undefined" ? storage.customerSpeedLevel : 0;
var customerSpeedCost = typeof storage.customerSpeedCost !== "undefined" ? storage.customerSpeedCost : 50;
var CUSTOMER_SPEED_MAX_LEVEL = 5;
var customerSpeedButton = game.addChild(LK.getAsset('upgradeButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 500,
	y: 2360
}));
var customerSpeedText = new Text2('Customer Speed $' + customerSpeedCost, {
	size: 36,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 260
});
customerSpeedText.anchor.set(0.5, 0.5);
customerSpeedText.x = 500;
customerSpeedText.y = 2360;
game.addChild(customerSpeedText);
function updateCustomerSpeedText() {
	if (customerSpeedLevel >= CUSTOMER_SPEED_MAX_LEVEL) {
		customerSpeedText.setText('Customer Speed (MAX)');
	} else {
		customerSpeedText.setText('Customer Speed $' + customerSpeedCost);
	}
}
customerSpeedButton.down = function () {
	if (customerSpeedLevel < CUSTOMER_SPEED_MAX_LEVEL && money >= customerSpeedCost) {
		money -= customerSpeedCost;
		customerSpeedLevel++;
		customerSpeedCost = customerSpeedCost * 2;
		// Increase customerSpeed by 20% (multiply by 1.2) for each upgrade
		customerSpeed = customerSpeed * 1.2;
		storage.customerSpeedLevel = customerSpeedLevel;
		storage.customerSpeedCost = customerSpeedCost;
		storage.money = money;
		LK.effects.flashObject(customerSpeedButton, 0x00FF00, 500);
		updateCustomerSpeedText();
	}
};
updateCustomerSpeedText();
// Add table button
var addTableButton = game.addChild(LK.getAsset('addTableButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1500,
	y: 2200
}));
var addTableCost = typeof storage.addTableCost !== "undefined" ? storage.addTableCost : 200 * (tableCount - 1 + 1); // 200, 400, 600, ...
var addTableText = new Text2('Add Table $' + addTableCost, {
	size: 36,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 260
});
addTableText.anchor.set(0.5, 0.5);
addTableText.x = 1500;
addTableText.y = 2200;
game.addChild(addTableText);
function updateAddTableText() {
	addTableText.setText('Add Table $' + addTableCost);
}
addTableButton.down = function () {
	if (money >= addTableCost && tables.length < 20) {
		money -= addTableCost;
		createTable(tables.length);
		tableCount++;
		addTableCost = 200 * (tableCount - 1 + 1);
		storage.tableCount = tableCount;
		storage.addTableCost = addTableCost;
		storage.money = money;
		LK.effects.flashObject(addTableButton, 0x00FF00, 500);
		updateAddTableText();
	}
};
updateAddTableText();
// Customer spawn timer
var customerSpawnTimer = 0;
// Game update
game.update = function () {
	// Update all waiters (main and extra)
	if (typeof waiter !== "undefined" && waiter.update) waiter.update();
	if (typeof game !== "undefined" && game.extraWaiters) {
		for (var w = 0; w < game.extraWaiters.length; w++) {
			if (game.extraWaiters[w] && game.extraWaiters[w].update) game.extraWaiters[w].update();
		}
	}
	// Update all chefs (main and extra)
	if (typeof chef !== "undefined" && chef.update) chef.update();
	if (typeof game !== "undefined" && game.extraChefs) {
		for (var c = 0; c < game.extraChefs.length; c++) {
			if (game.extraChefs[c] && game.extraChefs[c].update) game.extraChefs[c].update();
		}
	}
	// Update money display
	moneyText.setText('Money: $' + money);
	// Update last sold food info display
	if (lastSoldFoodName && lastSoldFoodPrice) {
		lastSoldText.setText('Son Satış: ' + lastSoldFoodName + ' ($' + lastSoldFoodPrice + ')');
	} else {
		lastSoldText.setText('');
	}
	// Update Top 5 Most Sold Foods Panel
	// Find top 5 indices by sales count
	var topIndices = [];
	for (var i = 0; i < foodSales.length; i++) topIndices.push(i);
	topIndices.sort(function (a, b) {
		return foodSales[b] - foodSales[a];
	});
	for (var i = 0; i < 5; i++) {
		var idx = topIndices[i];
		if (foodSales[idx] > 0) {
			// Show food icon, count, and total earned
			// Create icon if not already present
			if (!top5TextLines[i].foodIcon) {
				var icon = LK.getAsset(foodImageIds[idx], {
					anchorX: 0.5,
					anchorY: 0.5,
					// Place icon to the left of the text, with a small margin
					x: top5TextLines[i].x - 50,
					y: top5TextLines[i].y + 20,
					width: 40,
					height: 40
				});
				game.addChild(icon);
				top5TextLines[i].foodIcon = icon;
			} else {
				// Update icon to correct food type and position
				top5TextLines[i].foodIcon.setAsset(foodImageIds[idx]);
				// Place icon to the left of the text, with a small margin
				top5TextLines[i].foodIcon.x = top5TextLines[i].x - 50;
				top5TextLines[i].foodIcon.y = top5TextLines[i].y + 20;
				top5TextLines[i].foodIcon.visible = true;
			}
			// Calculate total earned for this food
			var totalEarned = foodSales[idx] * foodPrices[idx];
			top5TextLines[i].setText(i + 1 + '. ' + foodNames[idx] + ' - ' + foodSales[idx] + ' adet  $' + totalEarned);
		} else {
			top5TextLines[i].setText('');
			// Hide icon if present
			if (top5TextLines[i].foodIcon) {
				top5TextLines[i].foodIcon.visible = false;
			}
		}
	}
	// Spawn customers
	customerSpawnTimer++;
	if (customerSpawnTimer > 300) {
		// Every 5 seconds
		customerSpawnTimer = 0;
		// Check if there are waiting customers first
		var hasWaitingCustomer = false;
		for (var j = 0; j < customers.length; j++) {
			if (customers[j].state === 'entering' && !customers[j].targetTable) {
				hasWaitingCustomer = true;
				// Set waiting customer's position to the exit (register) location
				customers[j].x = registerX;
				customers[j].y = registerY;
				// Try to assign a table to waiting customer
				for (var k = 0; k < tables.length; k++) {
					if (!tables[k].occupied && !tables[k].customer && !tableReservations[k]) {
						customers[j].targetTable = tables[k];
						customers[j].targetTableIndex = k;
						tableReservations[k] = true; // Reserve the table
						break;
					}
				}
				break;
			}
		}
		// Only spawn new customer if no one is waiting
		if (!hasWaitingCustomer) {
			// Başlangıçta müşteri sayısı 1, her reklam yükseltmesinde +2 müşteri
			var advLevel = typeof advertisementLevel !== "undefined" ? advertisementLevel : typeof storage.advertisementLevel !== "undefined" ? storage.advertisementLevel : 0;
			var spawnCount = 1 + 2 * advLevel;
			for (var spawnIdx = 0; spawnIdx < spawnCount; spawnIdx++) {
				var customer = game.addChild(new Customer());
				// Customers now enter from the exit (register) location
				customer.x = registerX;
				customer.y = registerY;
				customers.push(customer);
				// Try to find available table
				for (var i = 0; i < tables.length; i++) {
					if (!tables[i].occupied && !tables[i].customer && !tableReservations[i]) {
						customer.targetTable = tables[i];
						customer.targetTableIndex = i;
						tableReservations[i] = true; // Reserve the table
						break;
					}
				}
				// If no table available, customer will wait
			}
		}
	}
	// Save periodically
	if (LK.ticks % 300 === 0) {
		storage.money = money;
	}
};