module.exports = Entity;

var mongoose = require('mongoose'),
	util = require('util'),
	log = require('../services/logger').log('BotAccount'),
	Registry = require('../helpers/registry'),
	SteamTradeOffers = require('../steam/tradeOffers'),
	steam = require('../steam/lib/steam_client.js'),
	events = require('events'),
	underscore = require('underscore'),
	moment = require('moment'),
	q = require('q');

function Entity() {
	/*if (!GLOBAL.BotAccountsRegistry) {
		GLOBAL.BotAccountsRegistry = new Registry();
	};*/

	var botAccountModel = mongoose.models['BotAccount'];

	if (!botAccountModel) {
		var botAccountSchema = new mongoose.Schema({
			accountName: String,
			password: String,
			shaSentryfile: Buffer,
			shaSentryUpdated: Date,
			isActive: Boolean,
			apiKey: {
				domain: String,
				value: String
			}
		}, { strict: true });

		botAccountSchema.methods.getLogOnOptions = instanceGetLogOnOptions;
		botAccountSchema.methods.connectAccount = instanceConnect;
		botAccountSchema.methods.initSteam = instanceInit;
		botAccountSchema.methods.loadInventory = instanceLoadInventory;
		botAccountSchema.methods.partnersInventory = instancePartnersInventory;
		botAccountSchema.methods.makeOffer = instanceMakeOffer;
		botAccountSchema.methods.getOffer = instanceGetOffer;
		botAccountSchema.methods.cancelOffer = instanceCancelOffer;
		botAccountSchema.methods.isConnected = function isConnected() {
			var self = this;
			return self.steamClient && self.steamClient.loggedOn;
		};
		botAccountSchema.methods.saveAsync = function () {
			var self = this;

			return q.Promise(function (resolve, reject) {
				self.save(function (err, item, numberAffected) {
					if (err) {
						reject(err);
					}
					resolve(item, numberAffected);
				});
			});
		};

		// hooks
		botAccountSchema.post('init', instanceInit);

		botAccountModel = mongoose.model('BotAccount', botAccountSchema);
	}

	Entity.prototype.BotAccountModel = botAccountModel;
};

// bot store
Entity.prototype.botAccountsRegistry = new Registry();

// todo
Entity.prototype.getRandomBot = function() {
	var self = this;
	return self.getBotForTrade();
};

Entity.prototype.getBotForTrade = function(deferred) {
	var self = this;
	if (!deferred)
		deferred = q.defer();

	var botAccount = self.botAccountsRegistry.nextValue();

	botAccount.connectAccount()
	.then(
		function () {
			deferred.resolve(botAccount);
		},
		function (error) {
			self.getBotForTrade(deferred);
	});

	return deferred.promise;
};

function onCriticalSteamError(error) {
	// remove entity from registry to allow relogin
	Entity.prototype.botAccountsRegistry.remove(this.accountName);
	log.error(error);
};

Entity.prototype.findByName = function(name) {
	var self = this;
	var deferred = q.defer();

	var bot = Entity.prototype.botAccountsRegistry.acquire(name);
	if (bot != undefined) {
		deferred.resolve(bot);
	}
	else {
		self.BotAccountModel
		.where('accountName', name)
		.findOne()
		.exec()
		.then(function (account) {
			if (!account) {
				deferred.reject(new Error('No bot account ' + name + ' was found in DB'));
				return;
			};

			Entity.prototype.botAccountsRegistry.add(account.accountName, account);
			deferred.resolve(account);

		}, function() {
			deferred.reject(new Error('Error while fetching the account ' + name));
		});
	};

	return deferred.promise;
};

Entity.prototype.LoadActive = function(isActive) {
	var self = this;
	var deferred = q.defer();

	self.BotAccountModel
	.where('isActive', isActive)
	.exec()
	.then(function (accounts) {
		if (!accounts) {
			deferred.reject(new Error('No bot accounts was found in DB'));
			return;
		};

		accounts.forEach(function (acc) {
			if (!Entity.prototype.botAccountsRegistry.acquire(acc.accountName)) {
				Entity.prototype.botAccountsRegistry.add(acc.accountName, acc);
			}
		});

		deferred.resolve(Entity.prototype.botAccountsRegistry.acquireAll());

	}, function () {
		deferred.reject(new Error('Error while fetching bot accounts'));
	});

	return deferred.promise;
};

instanceGetLogOnOptions = function () {
	var instance = this;

	return {
		account_name : instance.accountName,
		password : instance.password,
		sha_sentryfile: instance.shaSentryfile
	};
};

instanceLoadInventory = function () {
	var instance = this;
	var deferred = q.defer();

	instance.connectAccount()
		.then(function () {

		instance.tradeOffers.loadMyInventory({
			steamId: instance.steamClient.steamID,
			appId: 570, // dota2
			contextId: 2,
			language: "ru",
			tradableOnly: true
		}, function (err, items) {

			if (err) {
				onCriticalSteamError.call(instance, err);
				deferred.reject(err);
				return;
			};

			var tradableItems = underscore.filter(items, function(item) {
				return item.tradable && item.marketable;
			});
			deferred.resolve(tradableItems);

		});
	},function (error) {
		onCriticalSteamError.call(instance, error);
		deferred.reject(error);
	});

	return deferred.promise;
};

instancePartnersInventory = function (options) {
	var instance = this;
	var deferred = q.defer();

	instance.connectAccount()
		.then(function () {

		instance.tradeOffers.loadPartnerInventory({
			appId: 570, // dota2
			contextId: 2,
			partnerSteamId: options.partnerSteamId,
			partnerAccountId: options.partnerAccountId,
			language: "ru",
			tradableOnly: true
		}, function (err, items) {

			if (err) {
				onCriticalSteamError.call(instance, err);
				deferred.reject(err);
				return;
			};

			var tradableItems = underscore.filter(items, function(item) {
				return item.tradable && item.marketable;
			});
			deferred.resolve(tradableItems);

		});
	},function (error) {
		onCriticalSteamError.call(instance, error);
		deferred.reject(error);
	});

	return deferred.promise;
};

instanceMakeOffer = function (offerOptions) {
	var instance = this;
	var deferred = q.defer();

	instance.connectAccount()
		.then(function () {

		instance.tradeOffers.makeOffer(offerOptions,
		function (err, result) {
			if (err) {
				onCriticalSteamError.call(instance, err);
				deferred.reject(err);
				return;
			};

			deferred.resolve(result);
		});
	},function (error) {
		onCriticalSteamError.call(instance, error);
		deferred.reject(error);
	});

	return deferred.promise;
};

instanceGetOffer = function (options) {
	var instance = this;
	var deferred = q.defer();

	instance.connectAccount()
		.then(function () {

		instance.tradeOffers.getOffer(options, function (err, result) {
			if (err || !result) {
				onCriticalSteamError.call(instance, err || "Empty response");
				deferred.reject(err);
				return;
			};

			deferred.resolve(result.response);
		});
	},function (error) {
		onCriticalSteamError.call(instance, error);
		deferred.reject(error);
	});

	return deferred.promise;
};

instanceCancelOffer = function (options) {
	var instance = this;
	var deferred = q.defer();

	instance.connectAccount()
		.then(function () {

		instance.tradeOffers.cancelOffer(options, function (err, result) {
			if (err || !result) {
				onCriticalSteamError.call(instance, err || "Empty response");
				deferred.reject(err);
				return;
			};

			deferred.resolve(result.response);
		});
	},function (error) {
		onCriticalSteamError.call(instance, error);
		deferred.reject(error);
	});

	return deferred.promise;
};

instanceConnect = function (authCode, ignoreSteamErrors) {
	var instance = this;
	var deferred = q.defer();

	if (instance.isConnected()) {
		deferred.resolve(true);
	} else {
		var logOnOptions = instance.getLogOnOptions();
		if (authCode) {
			logOnOptions.auth_code = authCode;
		};

		instance.events.once('error', function (err) {
			onCriticalSteamError.call(instance, err);
			if (ignoreSteamErrors) {
				deferred.resolve(true);
			} else {
				deferred.reject(err);
			}
		});

		instance.events.once('connected', function() {
			deferred.resolve(true);
		});

		instance.events.once('needAuthCode', function () {
			//onCriticalSteamError.call(instance, new Error('Account ' + instance.accountName + ' need Steam Secure Code'));
			deferred.resolve(false);
		});

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

		instance.steamClient.connect();
	}

	return deferred.promise;
};

// adds steam connect event handle functions
instanceInit = function () {
	var instance = this;

	instance.steamClient = new steam.SteamClient();
	instance.steamUser = new steam.SteamUser(instance.steamClient);
	instance.tradeOffers = new SteamTradeOffers(instance.steamClient, instance.steamUser);

	//instance.events = new events.EventEmitter();
	instance.events = new events();

	instance.events.on('error', function (error) {
		log.error(error);
	});
	//steam.on('debug', console.log);

	instance.steamClient.on('error', function (error) {
		instance.events.emit('error', error);
	});

	instance.steamClient.on('logOnResponse', function (logonResp) {
		if (logonResp.eresult != steam.EResult.OK) {
			if (logonResp.eresult == steam.EResult.AccountLogonDenied) {
				instance.events.emit('needAuthCode');
			} else {
				instance.events.emit('error', logonResp);
			}
			return;
		}

		log.info('Logged on account ' + instance.accountName + ' accountFlags: ' + instance.tradeOffers.accountFlags.key);

		// could not do anything with limited account
		var newDeviceLimit = moment.utc().diff(instance.shaSentryUpdated, 'days') < 7;

		if (instance.tradeOffers.IsLimited || newDeviceLimit) {
			instance.isActive = false;
			instance.save(function (err) {
				if (err) {
					instance.events.emit('error', err);
					return;
				}

				log.info('Account ' + instance.accountName + ' was disabled.');
			});

			var error = new Error('Account ' + instance.accountName + ' is limited');
			log.error(error);
			instance.events.emit('error', error);
			return;
		}

		var options = { host: 'localhost' };

		if (instance.apiKey && instance.apiKey.domain == options.host) {
			options.apiKey = instance.apiKey.value;
		}

		instance.tradeOffers.setup(options, function (error) {
			if (error) {
				log.error(error);
				instance.events.emit('error', error);
				return;
			}

			log.info('Logged on web account ' + instance.accountName);
			var needUpdate = false;

			if (!instance.isActive) {
				instance.isActive = true;
				needUpdate = true;
			}

			if (!options.apiKey ) {
				instance.apiKey = {
					domain: options.host,
					value: instance.tradeOffers.APIKey
				};
				needUpdate = true;
			}

			if (needUpdate){
				instance.save(function (err) {
					if (err) {
						instance.events.emit('error', err);
						return;
					}
					log.info('Account updated ' + instance.accountName);
				});
			}

			instance.events.emit('connected');
		});
	});

	instance.steamUser.on('updateMachineAuth', function (data, callback) {
		//callback({ sha_file: require('crypto').createHash('sha1').update(data.bytes).digest('hex') });

		var sha = require('crypto').createHash('sha1');
		sha.update(data.bytes);
		var digest = sha.digest();

		callback({ sha_file: digest });

		instance.shaSentryfile = new Buffer(digest, 'binary');
		instance.shaSentryUpdated = moment.utc();
		instance.isActive = false;
		instance.save(function (error) {
			if (error) {
				instance.events.emit('error', error);
				return;
			}

			log.info('Sentry code updated ' + instance.accountName);
		});
	});

};