var config = require('./config.js'),
	fs = require('fs'),
	crypto = require('crypto');

/**
 *	configure express
 */
var expressApp = require('express')();

/**
 *	configure http server
 */
var http = require('http').Server(expressApp);
http.listen(8080);
/**
 *	configure request-json
 */
var reqJSON = require('request-json'),
	requestJSON = reqJSON.createClient(currentWorkingSite);
/**
 *	configure socket.io
 */
var io = require('socket.io')(http);

/**
 * ssfn config
 */
config.logOnOptions.sha_sentryfile = getSHA1(fs.readFileSync(__dirname + '/' + config.ssfn));

/**
 *	configure steam npm package
 *	configure steam-trade-offers package;
 */
var Steam = require('steam'),
	SteamTradeOffers = require('steam-tradeoffers'),
	SteamWebLogOn = require('steam-weblogon'),
	getSteamAPIKey = require('steam-web-api-key');

// if we've saved a server list, use it
if (fs.existsSync('servers')) {
	Steam.servers = JSON.parse(fs.readFileSync('servers'));
}

var steamClient = new Steam.SteamClient(),
	steamUser = new Steam.SteamUser(steamClient),
	steamOffers = new SteamTradeOffers(),
	steamFriends = new Steam.SteamFriends(steamClient),
	steamWebLogOn = new SteamWebLogOn(steamClient, steamUser);

steamClient.connect();

steamClient.on('connected', function() {
	steamUser.logOn(config.logOnOptions);
});

steamClient.on('error', function() {
	steamUser.logOn(config.logOnOptions);
});

steamClient.on('logOnResponse', function(logonResp) {
	if (logonResp.eresult == Steam.EResult.OK) {

		console.log('Steam client connected');

		steamFriends.setPersonaState(Steam.EPersonaState.Online); // to display your bot's status as "Online"

		steamWebLogOn.webLogOn(function(sessionID, newCookie) {
			getSteamAPIKey({
				sessionID: sessionID,
				webCookie: newCookie
			}, function(err, APIKey) {
				steamOffers.setup({
					sessionID: sessionID,
					webCookie: newCookie,
					APIKey: APIKey
				}, function() {

					console.log('Steam webLogon is fine');
					console.log('Initializing trade-offers/winning-tradeoffers request every X seconds');
					var intervalForOffers = executeIntervalForOffers(),
						intervalForPendingWinningOffers = executeIntervalForPendingWinningOffers();
				});
			});
		});

	}

});
/*steam.on('webSessionID', function(sessionID) {
	helper.msg('webSessionID ok');
	currentSessionId = sessionID;
	reWebLogOn(steam);
});


function reWebLogOn(steam, callback) {
	steam.webLogOn(function(newCookie) {
		helper.msg('webLogOn ok');

		offers.setup({
			sessionID: currentSessionId,
			webCookie: newCookie
		}, function() {
			if (typeof callback == "function") {
				callback();
			}
		});
	});
}*/
steamClient.on('servers', function(servers) {
	fs.writeFile('servers', JSON.stringify(servers));
});

steamUser.on('updateMachineAuth', function(sentry, callback) {
	fs.writeFileSync('sentry', sentry.bytes);
	callback({
		sha_file: getSHA1(sentry.bytes)
	});
});

steamOffers.on('debug', function(el) {
	console.log(el);
});


/**
 *	new round initialization;
 */

//check if there is a new round already active;
requestJSON.get('api/activeRoundGoingOn', function(err, res, json) {
	if (res.statusCode === 200) {
		if (json.success === true) {
			WinningPercentage = json.game.ticket;
			HashOfGame = json.game.game_hash;
			SaltOfGame = json.game.game_salt;
			currentGameID = json.game.id;
			console.log('Found new active round with id #' + json.game.id + '. Setting it up');
			//emit new round;
			io.emit('newGameRound', {
				gameID: currentGameID,
				gameHash: HashOfGame
			});
			requestJSON.post('api/getRoundPot', {
				gameid: currentGameID
			}, function(err, res, json) {
				if (res.statusCode === 200 && json.success) {
					io.emit('roundPot', {
						potplayers: json.html,
						potitems: json.potitems,
						timerisactive: (!timerID ? false : true)
					});
				} else {
					console.log('Error getting round pot');
				}
			});
			//get current pot items;
			requestJSON.get('api/getTotalPotItems/' + currentGameID, function(err, res, json_) {
				if (res.statusCode === 200 && json_.success) {
					currentTotalPotItems = json_.potItems;
					if (currentTotalPotItems >= config.itemsToStart) {
						startTimerForRound();
					}
				} else {
					console.log('Error api/getTotalPotItems');
				}
			});
			respondToConsole();
		} else {
			initiateNewRound();
		}
	}
});

function startTimerForRound() {
	//comes from request json activeRoundGoingOn;
	//not only;
	if (!timerID) {
		timerToTick = config.gameDuration;
		timerID = setInterval(function() {
			timerToTick--;

			var minute = Math.floor(timerToTick / 60),
				second = timerToTick % 60;

			second = second.toString();
			second = second.substr(0, 2);
			io.emit('timerTick', {
				timerToTick: minute + ":" + second
			});

			if (timerToTick <= 0) {
				console.log('Time is over');
				pickAWinner(currentGameID);
				clearInterval(timerID);
				timerID = false;
			}
		}, 1000);
	} else {
		console.log('timerID is defined already');
	}
}
var SaltOfGame = null,
	WinningPercentage = null,
	HashOfGame = null,
	currentGameID = null,
	currentTotalPotItems = 0,
	pendingWinningTradeoffers = [],
	timerID = null;

function respondToConsole() {
	console.log('Current Game Salt: ' + SaltOfGame);
	console.log('Next Winner percentage is: ' + WinningPercentage + '%');
	console.log('Current Game Hash is: ' + HashOfGame);
}

function initiateNewRound() {
	if (gameIsPaused) {
		gameIsPaused = false;
	}
	WinningPercentage = randomInRange(0, 100);
	SaltOfGame = makeid();
	HashOfGame = crypto.createHash('md5').update(SaltOfGame + ':' + WinningPercentage).digest('hex');
	currentGameID = null;
	//add new game to sql;
	addNewGameToDB();
}

var peers = [],
	pendingSentOffers = [],
	timerInterval = null,
	gameIsPaused = false,
	timerToTick = 0,
	pendingUserToGetOffered = [],
	chatMessages = [],
	pendingChatMessageForUserApiKey = [],
	userIDPendingOffer = [];

io.on('connection', function(socket) {
	//push client
	peers.push(socket);
	//emit peers
	socket.emit('peers', {
		totalPeers: peers.length
	});

	requestJSON.get('api/getChatMessages', function(err, res, json) {
		if (typeof res === 'undefined') return;

		if (res.statusCode === 200 && json.success) {
			io.emit('sendChatData', json.html);
		}
	});

	socket.on('ez', function() {
		requestJSON.post('api/getRoundPot', {
			gameid: (currentGameID ? currentGameID : 0)
		}, function(err, res, json) {

			if (typeof res === 'undefined') return;

			if (res.statusCode === 200 && json.success) {
				if (typeof io.sockets.connected === 'undefined' || typeof socket.id === 'undefined' || typeof io.sockets.connected[socket.id] === 'undefined') {
					return;
				}
				io.sockets.connected[socket.id].emit('roundPot', {
					potplayers: json.html,
					potitems: json.potitems,
					timerisactive: (!timerID ? false : true)
				});
			}
		});
	});

	//on disconnect
	socket.on('disconnect', function(socket) {
		//delete from peers list
		peers.splice(peers.indexOf(socket), 1);
		//update count
		io.emit('peers', {
			totalPeers: peers.length
		});
	});

	//requestOffer
	socket.on('requestOffer', function(data) {
		//rewrote;
		requestJSON.get('api/userExists/' + data.apikey, function(err, res, user) {
			//returns
			//**user.userid
			//**user.tradeurl
			//**user.steamid
			//**user.avatar
			if (res.statusCode === 200 && user.success) {

				if (userIDPendingOffer.indexOf(user.userid) > -1) {
					console.log('Cant offer him. Still awaiting for another offer to be accepted/declined of user: ' + user.userid);
					socket.emit('playerError', {
						apikey: data.apikey,
						html: "There is already a pending offer for you. Please either accept or decline it to be able to make a new trade. <div class='modal-close'>close</div>"
					});
					return;
				}

				if (pendingUserToGetOffered.indexOf(user.userid) > -1) {
					//there is a pending getOffer request; return;
					console.log('Cant offer him. Still awaiting for steam to respond for another trade offer of ' + user.userid);
					socket.emit('playerError', {
						apikey: data.apikey,
						html: "There is already a pending offer for you and we're afraid that steam is delayed :( <div class='modal-close'>close</div>"
					});
					return;
				}

				pendingUserToGetOffered.push(user.userid);
				userIDPendingOffer.push(user.userid);

				requestJSON.get('api/playerTotalPot/' + currentGameID + '/' + user.userid, function(err, res, json_) {

					if (res.statusCode === 200 && json_.success) {
						if (json_.total >= config.usersItemsLimit || ((data.items.length + json_.total) > config.usersItemsLimit)) {
							console.log('User ' + user.steamid + ' reached maximum skins deposited');
							socket.emit('playerError', {
								apikey: data.apikey,
								html: "You can't deposit more than 10 skins <div class='modal-close'>close</div>"
							});
							pendingUserToGetOffered.splice(pendingUserToGetOffered.indexOf(user.userid), 1);
							userIDPendingOffer.splice(userIDPendingOffer.indexOf(user.userid), 1);
							return;
						} else {
							var partnerInventoryRetry = 5;

							var token = user.tradeurl;
							token = token.substr(token.indexOf('&token') + 7);

							var accountid = user.tradeurl;
							accountid = accountid.substr(accountid.indexOf('?partner') + 9);
							accountid = accountid.substring(0, accountid.indexOf('&'));

							var loadPartnerInventory = function() {
								partnerInventoryRetry--;
								steamOffers.loadPartnerInventory({
									appId: 730,
									contextId: 2,
									partnerAccountId: accountid
								}, function(err, items) {
									if (err) {
										console.log('Error loadPartnerInventory ' + err);
										if (partnerInventoryRetry >= 0) {
											console.log('Retry loadPartnerInventory step: ' + partnerInventoryRetry);
											setTimeout(function() {
												loadPartnerInventory();
											}, 2000);
										} else {
											userIDPendingOffer.splice(userIDPendingOffer.indexOf(user.userid), 1);
										}
									} else {
										var lengthToCheck = data.items.length,
											itemsExist = 0,
											itemsInfo = [];

										for (var i = 0; i < items.length; i++) {
											for (var z in data.items) {
												if (items[i].id === data.items[z] && items[i].tradable) {
													itemsInfo.push({
														name: items[i].market_hash_name
													});
													itemsExist += 1;
													continue;
												}
												if (itemsExist === lengthToCheck) break;
											}
										}
										//after loading inventory
										if (itemsExist === lengthToCheck) {
											//all items proposed from site exists
											//move on and make him an offer;

											var itemsToRequest = buildItemsArrayToRequest(data.items);

											console.log('Trying to make ' + user.steamid + ' an offer');
											//check if he has alreayd a pending offer with same assetid;
											if (pendingSentOffers.length > 0) {

												var newArray_ = [];
												for (var z in itemsToRequest) {
													newArray_.push(itemsToRequest[z].assetid);
												}

												for (var z in pendingSentOffers) {
													if (pendingSentOffers[z].userid == user.userid) {
														for (var ex in pendingSentOffers[z].assetids) {
															if (newArray_.indexOf(pendingSentOffers[z].assetids[ex]) > -1) {
																socket.emit('playerError', {
																	apikey: data.apikey,
																	html: "You tried to deposit an already pending item. <div class='modal-close'>close</div>"
																});
																pendingUserToGetOffered.splice(pendingUserToGetOffered.indexOf(user.userid), 1);
																userIDPendingOffer.splice(userIDPendingOffer.indexOf(user.userid), 1);
																return;
															}
														}
													}
												}

											}

											var makeHimAnOfferTries = 5;
											var makeHimAnOffer = function() {
												steamOffers.makeOffer({
													partnerAccountId: accountid,
													accessToken: token,
													itemsFromMe: [],
													itemsFromThem: itemsToRequest,
													message: 'Deposit for Game # ' + currentGameID + '. Thanks for gambling.'
												}, function(err, response) {

													if (err) {
														console.log('Error making an offer: Retry ' + makeHimAnOfferTries);
														makeHimAnOfferTries--;
														if (makeHimAnOfferTries > 0) {
															setTimeout(function() {
																makeHimAnOffer();
															}, 3000);
														} else {
															socket.emit('playerError', {
																apikey: data.apikey,
																html: "Couldn't reach steam. Please try again. <div class='modal-close'>close</div>"
															});
															pendingUserToGetOffered.splice(pendingUserToGetOffered.indexOf(user.userid), 1);
															userIDPendingOffer.splice(userIDPendingOffer.indexOf(user.userid), 1);
														}
														return;
													}

													requestJSON.post('api/getItemInfo', {
														items: itemsInfo
													}, function(err, res, json) {
														if (json.success === true) {
															var assetidsMotherfucker = [];
															for (var z in itemsToRequest) {
																assetidsMotherfucker.push(itemsToRequest[z].assetid);
															}
															pendingSentOffers.push({
																tradeofferid: response.tradeofferid,
																steamid: user.steamid,
																userid: user.userid,
																items: json.items,
																assetids: assetidsMotherfucker
															});
															socket.emit('playerDeposited', {
																apikey: data.apikey,
																html: "Your deposit has been successful <a href='https://steamcommunity.com/tradeoffer/" + response.tradeofferid + "' class='link' target='_blank'>Click here to view the trade offer</a><div class='modal-close'>close</div>",
															});
															console.log('Offer with id ' + response.tradeofferid + ' of user with steam id ' + user.steamid + ' has been pushed');
														}
														pendingUserToGetOffered.splice(pendingUserToGetOffered.indexOf(user.userid), 1);
													});

												});
											}
											makeHimAnOffer();

										} else {
											socket.emit('playerError', {
												apikey: data.apikey,
												html: "Couldn't find deposited items in your inventory. Please try again. <div class='modal-close'>close</div>"
											});
											pendingUserToGetOffered.splice(pendingUserToGetOffered.indexOf(user.userid), 1);
										}
									}
								});

							};
							loadPartnerInventory();
						}
					}
				});
			}
		});
	});

	socket.on('sendChatMessage', function(data) {

		if (pendingChatMessageForUserApiKey.indexOf(data.apikey) > -1) {
			console.log('Didnt push his previous message. Returning');
			return;
		}

		pendingChatMessageForUserApiKey.push(data.apikey);

		requestJSON.post('api/saveChatMessage', {
			apikey: data.apikey,
			message: data.message
		}, function(err, res, json) {
			if (res.statusCode === 200 && json.success) {
				io.emit('sendChatData', json.html);
			} else {
				console.log('Error api/saveChatMessage');
			}
			pendingChatMessageForUserApiKey.splice(pendingChatMessageForUserApiKey.indexOf(data.apikey), 1);
		});

	});

	/**
	 * admin emits
	 */
	socket.on('deletedMessages', function() {
		requestJSON.get('api/getChatMessages', function(err, res, json) {
			if (res.statusCode === 200 && json.success) {
				io.emit('sendChatData', json.html);
			}
		});
	});

	if (currentGameID) {
		socket.emit('newGameRound', {
			gameID: currentGameID,
			gameHash: HashOfGame
		});
	}
});


var buildItemsArrayToRequest = function(items) {
	var itemsToSend = [];

	for (var z in items) {
		//z key
		//items[0] item.id;
		itemsToSend.push({
			appid: 730,
			contextid: 2,
			amount: 1,
			assetid: items[z]
		});
	}
	return itemsToSend;
}

/**
 * functions;
 */
var pendingHoldTradeOfferIds = [],
	pendingHoldWinnerTradeOfferIds = [];

var timesCheckedAnID = [];

function executeIntervalForOffers() {
	setInterval(function() {
		if (pendingSentOffers.length > 0 && !gameIsPaused) {
			pendingSentOffers.forEach(function(offer, i) {

				console.log('Checking ' + offer.tradeofferid);

				if (typeof offer === 'undefined') {
					return;
				}

				if (pendingHoldTradeOfferIds.indexOf(offer.tradeofferid) > -1) {
					//there is a pending getOffer request; return;
					console.log(timesCheckedAnID[offer.tradeofferid]);
					if (timesCheckedAnID[offer.tradeofferid] >= 20) {
						console.log('Checked him 5 times. Dodge');
						timesCheckedAnID.splice(timesCheckedAnID.indexOf(timesCheckedAnID[offer.tradeofferid]), 1);
						pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
						return;
					} else {
						timesCheckedAnID[offer.tradeofferid] = timesCheckedAnID[offer.tradeofferid] + 1;
						console.log('Returning. Awaiting for steam response');
						return;
					}
				}

				timesCheckedAnID[offer.tradeofferid] = 1;

				pendingHoldTradeOfferIds.push(offer.tradeofferid);

				steamOffers.getOffer({
					tradeofferid: offer.tradeofferid
				}, function(error, body) {
					if (body && body.response && body.response.offer && body.response.offer.trade_offer_state) {

						switch (body.response.offer.trade_offer_state) {
							case 1:
							case 4:
							case 5:
							case 6:
							case 7:
							case 8:
							case 9:
							case 10:
								console.log('Tradeofferid ' + body.response.offer.tradeofferid + ' has either declined/expired/unavailabe. Return');
								console.log('Should remove ' + body.response.offer.tradeofferid);
								//removing user from being pending so he can make an offer again;
								userIDPendingOffer.splice(userIDPendingOffer.indexOf(offer.userid), 1);
								//removing pending tradeofferid;
								pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
								//removing pending sent offer;
								pendingSentOffers = removeFromArray(pendingSentOffers, offer.tradeofferid);
								break;
							case 2: //still active
								console.log('Offer with id ' + body.response.offer.tradeofferid + ' still active. Return.')
								//console.log(body.response.descriptions);
								pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
								break;
							case 3: //accepted
								console.log('Recipient ' + body.response.offer.steamid_other + ' has accepted the offer with id ' + body.response.offer.tradeofferid + '. Pushing the guy into pot');
								if (typeof offer === 'undefined' || !offer.userid) {
									return false;
								}
								requestJSON.post('api/addPotItems', {
									gameid: currentGameID,
									userid: offer.userid,
									items: offer.items
								}, function(err, res, json) {
									if (typeof res !== 'undefined' && res.statusCode === 200) {
										if (json.success) {
											//json.total_items
											console.log('All good with ' + body.response.offer.tradeofferid + '. Emitting');
											currentTotalPotItems += json.total_items;
											requestJSON.post('api/getRoundPot', {
												gameid: currentGameID
											}, function(err, res, json) {
												if (res.statusCode === 200 && json.success) {
													io.emit('roundPot', {
														potplayers: json.html,
														potitems: json.potitems,
														timerisactive: (!timerID ? false : true)
													});
												}
											});
											io.emit('enterPot', {
												gameid: currentGameID,
												steamid: body.response.offer.steamid_other,
												html: "You entered Game Round # " + currentGameID + ". You can view more stats on the Current Pot Players sidebar. <div class='modal-close'>close</div>"
											});

											requestJSON.get('api/getTotalPotItems/' + currentGameID, function(err, res, json_) {
												if (res.statusCode === 200 && json_.success) {
													currentTotalPotItems = json_.potItems;
													if (currentTotalPotItems >= config.itemsToStart) {
														if (wheelStillSpinning) {
															setTimeout(function() {
																startTimerForRound();
															}, 10000);
														} else {
															startTimerForRound();
														}
													}
													pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
												}
											});
										}
									} else {
										console.log('Error api/addPotItems');
										console.log(json);
									}
								});

								//removing user from being pending so he can make an offer again;
								userIDPendingOffer.splice(userIDPendingOffer.indexOf(offer.userid), 1);

								pendingSentOffers = removeFromArray(pendingSentOffers, offer.tradeofferid);
								break;
						}

					} else {
						console.log('No body or error occured');
						pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
						return false;
					}
				});
				//offer.tradeofferid;
				//offer.steamid;
				//offer.userid;
				//offer.items[z].id//name//price;
			});
		}
	}, 10000);
}

function executeIntervalForPendingWinningOffers() {
	//comes from weblogon
	setInterval(function() {
		/*pendingWinningTradeoffers.push({
			gameRound: gameID,
			tradeofferid: response.tradeofferid
			assetids: []
		});*/
		if (pendingWinningTradeoffers.length > 0) {
			pendingWinningTradeoffers.forEach(function(winningoffer, i) {
				if (typeof winningoffer === 'undefined') {
					console.log('Undefined what the fuck');
					return;
				}

				if (pendingHoldWinnerTradeOfferIds.indexOf(winningoffer.tradeofferid) > -1) {
					console.log('Returning. Awaiting for steam response. Winnings');
					return;
				}

				pendingHoldWinnerTradeOfferIds.push(winningoffer.tradeofferid);

				steamOffers.getOffer({
					tradeofferid: winningoffer.tradeofferid
				}, function(error, body) {
					if (body && body.response && body.response.offer && body.response.offer.trade_offer_state) {

						switch (body.response.offer.trade_offer_state) {
							case 2:
								console.log('Winner tradeofferid ' + body.response.offer.tradeofferid + ' is still active');
								pendingHoldWinnerTradeOfferIds.splice(pendingHoldWinnerTradeOfferIds.indexOf(body.response.offer.tradeofferid), 1);
								break;
							case 3:
								console.log('Winner tradeofferid ' + body.response.offer.tradeofferid + ' got accepted. Remove items from being held.');
								requestJSON.post('api/updateGame', {
									state: 'completed',
									gameid: winningoffer.gameRound
								}, function(err, res, json) {
									if (res.statusCode === 200 && json.success) {
										console.log('Game updated to completed');
									}
								});
								//remove body.response.offer.tradeofferid from pendingwinningtradeofferids;
								//pendingHoldTradeOfferIds.splice(pendingHoldTradeOfferIds.indexOf(offer.tradeofferid), 1);
								//pendingSentOffers = removeFromArray(pendingSentOffers, body.response.offer.tradeofferid);
								pendingHoldWinnerTradeOfferIds.splice(pendingHoldWinnerTradeOfferIds.indexOf(body.response.offer.tradeofferid), 1);
								pendingWinningTradeoffers = removeFromArray(pendingWinningTradeoffers, body.response.offer.tradeofferid);
								break;
							case 7:
								console.log('Winner tradeofferid ' + body.response.offer.tradeofferid + ' is retarded and he declined winnings. Remove items from being held.');
								pendingHoldWinnerTradeOfferIds.splice(pendingHoldWinnerTradeOfferIds.indexOf(body.response.offer.tradeofferid), 1);
								pendingWinningTradeoffers = removeFromArray(pendingWinningTradeoffers, body.response.offer.tradeofferid);
								break;
						}
					} else {
						console.log('No body or error occured');
						pendingHoldWinnerTradeOfferIds.splice(pendingHoldWinnerTradeOfferIds.indexOf(winningoffer.tradeofferid), 1);
						return false;
					}
				});

			});
		}
	}, 20000);
}

function makeid() {
	var text = "";
	var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

	for (var i = 0; i < 16; i++)
		text += possible.charAt(Math.floor(Math.random() * possible.length));

	return text;
}

function randomInRange(min, max) {
	return Math.random() < 0.5 ? ((1 - Math.random()) * (max - min) + min) : (Math.random() * (max - min) + min);
}

function getSHA1(bytes) {
	var shasum = crypto.createHash('sha1');
	shasum.end(bytes);
	return shasum.read();
}

function removeFromArray(array, itemToRemove) {
	var newArray = array.filter(function(el) {
		return el.tradeofferid !== itemToRemove
	});
	return newArray;
}

function addNewGameToDB(callback) {
	requestJSON.post('api/addNewGame/', {
		hash: HashOfGame,
		salt: SaltOfGame,
		ticket: WinningPercentage.toString(),
		pass: superPassword
	}, function(err, res, json) {
		if (res.statusCode === 200) {
			if (json.success) {
				if (callback && typeof callback === 'function') {
					callback();
				}
				currentGameID = json.game_id;
				io.emit('newGameRound', {
					gameID: currentGameID,
					gameHash: HashOfGame
				});
				console.log('Current game saved with Game Number #' + json.game_id);
				respondToConsole();
			}
		} else {
			console.log('Error api/addNewGame');
		}
	});
}

var wheelStillSpinning = false;

function initiateWheelForGame(currentGameID, userID) {
	//comes from pickAWinner;
	wheelStillSpinning = true;

	requestJSON.get('api/potPlayersForGame/' + currentGameID, function(err, res, json) {
		if (res.statusCode === 200 && json.success) {
			//json.wheelData;
			//json.jackpot;
			//json.totalDepositedSkins;
			io.emit('startWheel', {
				players: json.wheelData,
				winnerid: userID,
				jackpot: json.jackpot,
				totalSkins: json.totalDepositedSkins,
			});
			setTimeout(function() {
				wheelStillSpinning = false;
			}, 7000);
		} else {
			console.log('Error api/potPlayersForGame');
		}
	});
}

function completeCurrentGame(gameID, userID) {
	//comes from pickAWinner;
	requestJSON.post('api/completeCurrentGame', {
		gameid: gameID,
		userid: userID,
		pass: superPassword
	}, function(err, res, json) {
		if (res.statusCode === 200 && json.success) {
			//we got the itemNames to give;
			//json.usersteamid
			//json.tradeurl,
			//json.apikey
			var itemNamesToGive = json.itemNames;
			console.log('Loading my inventory to give ' + json.itemNames.length + ' items.');
			steamOffers.loadMyInventory({
				appId: 730,
				contextId: 2,
				tradableOnly: true
			}, function(err, items) {

				var itemsFound = [],
					cachedInventory = items;

				console.log('Inventory total items: ' + cachedInventory.length);

				if (pendingWinningTradeoffers.length > 0) {
					var assetidsToRemove = [];

					for (var w in pendingWinningTradeoffers) {
						for (var omi in pendingWinningTradeoffers[w].assetids) {
							assetidsToRemove.push(pendingWinningTradeoffers[w].assetids[omi]);
						}
					}

					for (var q in cachedInventory) {
						for (var ez in assetidsToRemove) {
							//assetidsToRemove[ez] == assetid
							if (assetidsToRemove[ez] === cachedInventory[q].id) {
								console.log('Removed ' + cachedInventory[q].id + ' from inventory');
								cachedInventory.splice(q, 1);
							}
						}
					}
				};

				for (var key in itemNamesToGive) {
					//key = name to check
					for (var x in cachedInventory) {

						if (cachedInventory[x].market_hash_name === itemNamesToGive[key]) {

							itemsFound.push({
								name: cachedInventory[x].market_hash_name,
								assetid: cachedInventory[x].id
							});

							cachedInventory.splice(x, 1);
							break;

						}

					}
				}

				/*newly written*/
				/*sending to other bot an offer*/
				if (cachedInventory.length >= 200) {
					console.log('Making an offer to our bot');
					makeAnOfferToOurBot(cachedInventory);
				}

				if (itemsFound.length === itemNamesToGive.length) {
					console.log('Found all items. Proceeding to give items to winner with userID: ' + userID + ' for gameID: ' + gameID);
				} else {
					console.log('Didnt found all items');
				}

				var itemsToSend = [],
					retriesToSendWinnerItems = 5;

				for (var wiss in itemsFound) {
					itemsToSend.push({
						"appid": 730,
						"contextid": 2,
						"amount": 1,
						"assetid": itemsFound[wiss].assetid
					});
				}

				var sendWinner = function() {
					retriesToSendWinnerItems--;
					var token = null,
						accountid = null;

					if (!json.tradeurl) {
						//needs a player message error etc;
						return console.log('He has not trade url');
					}

					token = json.tradeurl;
					token = token.substr(token.indexOf('&token') + 7);
					console.log('Winning user token: ' + token);

					accountid = json.tradeurl;
					accountid = accountid.substr(accountid.indexOf('?partner') + 9);
					accountid = accountid.substring(0, accountid.indexOf('&'));

					console.log('Winning user account id: ' + accountid);

					steamOffers.makeOffer({
						partnerAccountId: accountid,
						accessToken: token,
						itemsFromMe: itemsToSend,
						itemsFromThem: [],
						message: 'Congratulations ! You won Game Number #' + gameID + '. These are your winnings. Thanks for gambling.'
					}, function(err, response) {
						if (err) {
							console.log('Error sending offer to userID ' + userID + ' for winning game number ' + gameID);
							if (retriesToSendWinnerItems >= 0) {
								console.log('Retry sending offer: ' + retriesToSendWinnerItems);
								setTimeout(function() {
									sendWinner();
								}, 2000);
							} else {
								io.emit('playerError', {
									apikey: json.apikey,
									html: "We tried 5 times to send you your winnings. Our bot will retry shortly. <div class='modal-close'>close</div>"
								});
							}
							return;
						}
						console.log('Trade offer for winnings of round #' + gameID + ' was successful. Emitting winnerMessage');
						requestJSON.post('api/updateGame', {
							state: 'semicompleted',
							gameid: gameID
						}, function(err, res, json) {
							if (res.statusCode === 200 && json.success) {
								console.log('Round: ' + gameID + ' has been updated to semicompleted');
							}
						});
						io.emit('winnerMessage', {
							apikey: json.apikey,
							html: "Your winnings has been sent to you. <a href='https://steamcommunity.com/tradeoffer/" + response.tradeofferid + "' class='link' target='_blank'>Click here to accept your winnings.</a><div class='modal-close'>close</div>",
						});
						//pushing item assetids to be onhold;
						var smallArray = [];
						for (var o in itemsToSend) {
							smallArray.push(itemsToSend[o].assetid);
						}
						//pushing winning trade offer id for check up every 20s;
						pendingWinningTradeoffers.push({
							gameRound: gameID,
							tradeofferid: response.tradeofferid,
							assetids: smallArray
						});
						//emitting end-game to clear shit;
						io.emit('endRound', {
							gameid: gameID