/**** 
* Classes
****/
// ValueIndicator class to represent the current value of the stock on the graph
var ValueIndicator = Container.expand(function () {
	var self = Container.call(this);
	var indicatorGraphics = self.createAsset('valueIndicator', 'Current Stock Value Indicator', 0.5, 0.5);
	self.updatePosition = function (price) {
		// Position ValueIndicator based on the stock price
		self.x = 0; // Start from the left side
		self.y = 2732 / 2; // Start from the left side
		var targetX = game.width / 2; // Center horizontally
		var targetY = game.height / 2; // Center vertically
		// Custom tween function to animate the ValueIndicator
		var startTime = Date.now();
		var duration = 3000; // Duration in milliseconds
		var startX = self.x;
		var endX = targetX;
		var animateX = function animateX() {
			var endTime = startTime + duration;
			var currentTime = Date.now();
			var timeRemaining = endTime - currentTime;
			var nextX = startX + (endX - startX) * (1 - timeRemaining / duration);
			self.x = nextX;
			if (currentTime < endTime) {
				LK.setTimeout(animateX, 16);
			}
		};
		animateX();

		// Add GraphLine to the ValueIndicator
		self.graphLine = self.addChild(new GraphLine());
		// Update the graph line whenever the ValueIndicator updates its position
		self.graphLine.updateGraph(stockValuesHistory);
		// Function to animate the ValueIndicator based on stockValuesHistory
		var historyIndex = 0; // Start with the first value in the history
		var updateYPosition = function updateYPosition() {
			if (historyIndex < stockValuesHistory.length) {
				var targetY = game.height / 2 - stockValuesHistory[historyIndex] * 10; // Scale the stock value for display
				var startY = self.y;
				var duration = 1000; // Duration in milliseconds for Y movement
				var startTime = Date.now();
				var animateY = function animateY() {
					var currentTime = Date.now();
					var timeElapsed = currentTime - startTime;
					var newY = startY + (targetY - startY) * (timeElapsed / duration);
					self.y = newY;
					if (timeElapsed < duration) {
						LK.setTimeout(animateY, 16);
					} else {
						self.y = targetY; // Ensure final position is set
					}
				};
				animateY();
				historyIndex++;
				LK.setTimeout(updateYPosition, 1000); // Update position every second
			}
		};
		updateYPosition();
	};
});
// GraphLine class to represent the graph line behind the ValueIndicator
var GraphLine = Container.expand(function () {
	var self = Container.call(this);
	var lineGraphics = self.createAsset('graphLineGraphics', 'Graph Line Graphics', 0, 0);
	self.addChild(lineGraphics);
	self.updateGraph = function (history) {
		lineGraphics.clear();
		for (var i = 0; i < history.length - 1; i++) {
			var startX = game.width / (history.length - 1) * i;
			var startY = game.height / 2 - history[i] * 10;
			var endX = game.width / (history.length - 1) * (i + 1);
			var endY = game.height / 2 - history[i + 1] * 10;
			var lineLength = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
			var angle = Math.atan2(endY - startY, endX - startX);
			var lineAsset = self.createAsset('line', 'Graph Line Segment', 0, 0);
			lineAsset.width = lineLength;
			lineAsset.height = 2; // Set a small height for the line
			lineAsset.rotation = angle;
			lineAsset.x = startX;
			lineAsset.y = startY;
			self.addChild(lineAsset);
		}
	};
});
// Player class to represent the player's portfolio
var Player = Container.expand(function () {
	var self = Container.call(this);
	self.balance = 100; // Start with $100
	self.stocks = {}; // Object to hold stocks and quantities
	self.buyStock = function (stock, quantity) {
		var cost = stock.getPrice() * quantity;
		if (self.balance >= cost) {
			self.balance -= cost;
			if (!self.stocks[stock]) {
				self.stocks[stock] = 0;
			}
			self.stocks[stock] += quantity;
		}
	};
	self.sellStock = function (stock, quantity) {
		if (self.stocks[stock] && self.stocks[stock] >= quantity) {
			self.balance += stock.getPrice() * quantity;
			self.stocks[stock] -= quantity;
			if (self.stocks[stock] === 0) {
				delete self.stocks[stock];
			}
		}
	};
	self.getBalance = function () {
		return self.balance;
	};
	self.getPortfolio = function () {
		return self.stocks;
	};
});

/**** 
* Initialize Game
****/
var game = new LK.Game({
	// No need to set backgroundColor since we are adding a background asset
});

/**** 
* Game Code
****/
// Create and add background asset
var background = game.addChild(LK.getAsset('background', 'Game background', 0.5, 0.5));
background.x = 1024; // Center x position
background.y = 2732 - background.height / 2; // Center y position

// Initialize game elements
var player = new Player();
var stocks = [];
// Initialize stock values history with the first value of $10
var stockValuesHistory = [10];
// Add 10 other random stock values
for (var i = 0; i < 10; i++) {
	stockValuesHistory.push(Math.floor(Math.random() * 100) + 1);
}
var stockDisplay = []; // Array to hold stock display elements
var balanceText = new Text2('Balance: $' + player.getBalance(), {
	size: 50,
	fill: "#ffffff"
});
// Create and add ValueIndicator to the game
var valueIndicator = game.addChild(new ValueIndicator());
valueIndicator.updatePosition(100); // Example stock price
balanceText.anchor.set(0.5, 0);
LK.gui.top.addChild(balanceText);

// Update the player's balance display
function updateBalanceDisplay() {
	balanceText.setText('Balance: $' + player.getBalance().toFixed(2));
}

// Function to handle buying stocks
function buyStock(stock) {
	player.buyStock(stock, 1); // Buy 1 stock for simplicity
	updateBalanceDisplay();
}

// Function to handle selling stocks
function sellStock(stock) {
	player.sellStock(stock, 1); // Sell 1 stock for simplicity
	updateBalanceDisplay();
}

// Main game loop
LK.on('tick', function () {
	// Check for game over conditions (e.g., player runs out of money)
	if (player.getBalance() <= 0) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
	}
});