/**** 
* Classes
****/
var GraphSegment = Container.expand(function () {
	var self = Container.call(this);
	var segmentGraphics = self.createAsset('graphSegment', 'Graph Segment', 0, 0);
	self.addChild(segmentGraphics);
});
// SpecialGraphSegment class to represent the special segment that follows the ValueIndicator
var SpecialGraphSegment = Container.expand(function () {
	var self = Container.call(this);
	var segmentGraphics = self.createAsset('graphSegment', 'Special Graph Segment', 0, 0);
	self.addChild(segmentGraphics);
	self.updateSegment = function (indicatorX, indicatorY) {
		self.x = indicatorX;
		self.y = game.height / 2;
		// Display text for start position
		if (!self.startText) {
			self.startText = new Text2('Start: (0,0)', {
				size: 30,
				fill: '#ffffff'
			});
			self.startText.anchor.set(0.5, 0);
			LK.gui.bottomLeft.addChild(self.startText);
		}
		self.startText.setText('Start: (' + self.x.toFixed(2) + ',' + self.y.toFixed(2) + ')');
		var angle = Math.atan2(indicatorY - self.y, indicatorX - self.x);
		self.rotation = angle;
		var distance = Math.sqrt(Math.pow(indicatorX - self.x, 2) + Math.pow(indicatorY - self.y, 2));
		self.width = distance;
		segmentGraphics.pivot.x = 0;
		segmentGraphics.pivot.y = segmentGraphics.height / 2;
		// Display text for end position
		if (!self.endText) {
			self.endText = new Text2('End: (0,0)', {
				size: 30,
				fill: '#ffffff'
			});
			self.endText.anchor.set(0.5, 0);
			LK.gui.bottomRight.addChild(self.endText);
		}
		self.endText.setText('End: (' + indicatorX.toFixed(2) + ',' + indicatorY.toFixed(2) + ')');
		updateTexts(game);
	};
});
var GraphLine = Container.expand(function () {
	var self = Container.call(this);
	self.updateGraph = function (stockValuesHistory) {
		// Clear existing segments
		self.segments.forEach(function (segment) {
			segment.destroy();
		});
		self.segments = [];
		// Create new segments based on stockValuesHistory
		for (var i = 0; i < stockValuesHistory.length - 1; i++) {
			var segment = new GraphSegment();
			// Set segment start position based on the first value
			segment.x = i * (game.width / stockValuesHistory.length);
			segment.y = game.height / 2 - stockValuesHistory[i] * 10;
			// Set segment end position based on the second value
			var nextX = (i + 1) * (game.width / stockValuesHistory.length);
			var nextY = game.height / 2 - stockValuesHistory[i + 1] * 10;
			// Calculate rotation based on the price difference
			var angle = Math.atan2(nextY - segment.y, nextX - segment.x);
			segment.rotation = angle;
			// Calculate and set the width of the segment
			var distance = Math.sqrt(Math.pow(nextX - segment.x, 2) + Math.pow(nextY - segment.y, 2));
			segment.width = distance;
			// Adjust the pivot to rotate around the starting point
			segment.pivot.x = 0;
			segment.pivot.y = segment.height / 2;
			self.segments.push(segment);
			self.addChild(segment);
		}
	};
});
// 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 and update SpecialGraphSegment
		game.specialSegment = new SpecialGraphSegment();
		self.parent.addChild(game.specialSegment);
		var startTime = Date.now();
		var duration = 3000; // Duration in milliseconds
		var startX = self.x;
		var endX = targetX;
		var startY = self.y;
		var endY = targetY;
		var animateX = function animateX() {
			var endTime = startTime + duration;
			var currentTime = Date.now();
			var timeRemaining = endTime - currentTime;
			var nextX = startX + (endX - startX) * (1 - timeRemaining / duration);
			var nextY = startY + (endY - startY) * (1 - timeRemaining / duration);
			self.x = nextX;
			this.parent.specialSegment.updateSegment(nextX, nextY);
			if (currentTime < endTime) {
				LK.setTimeout(animateX, 16);
			} else {
				// Removed the call to self.graphLine.updateGraph as it's undefined in this context
			}
		};
		animateX();
		// 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(function () {
					updateYPosition();
					if (historyIndex > 0) {
						var previousPrice = stockValuesHistory[historyIndex - 1];
						var currentPrice = stockValuesHistory[historyIndex];
						var segment = new GraphSegment();
						segment.x = (historyIndex - 1) * (game.width / stockValuesHistory.length); // Position at the previous index
						segment.y = game.height / 2 - previousPrice * 10; // Scale the previous stock value for display
						segment.width = game.width / stockValuesHistory.length; // Width of the segment
						// Calculate rotation based on the price difference
						var angle = Math.atan2(currentPrice - previousPrice, segment.width);
						segment.rotation = angle;
						// Position the segment based on the previous price
						segment.x = (historyIndex - 1) * segment.width;
						segment.y = game.height / 2 - previousPrice * 10;
						// Adjust the pivot to rotate around the starting point
						segment.pivot.x = 0;
						segment.pivot.y = segment.height / 2;
						self.parent.addChild(segment); // Add the segment to the graph
					}
				}, 1000); // Update position every second and add a new segment
			}
		};
		updateYPosition();
	};
});
// 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 specialSegmentPositionText = new Text2('', {
	size: 30,
	fill: '#ffffff'
});
specialSegmentPositionText.anchor.set(0.5, 1);
LK.gui.bottom.addChild(specialSegmentPositionText);
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();
	}
});
function updateTexts(gameRef) {
	// Implementation of updateTexts with a reference to the game
	// This function will be called from SpecialGraphSegment.updateSegment
	if (gameRef.specialSegment && gameRef.specialSegment.startText && gameRef.specialSegment.endText) {
		specialSegmentPositionText.setText('Start: (' + gameRef.specialSegment.startText.text + ') End: (' + gameRef.specialSegment.endText.text + ')');
	}
}