var Rx = require("rx");
var assert = require("assert");

import { Helper, BotManager } from './Core';
import { Language } from './Language';

declare var assert;

Rx.Observable.prototype.start = function(onError) {
	return this.do(
		c => {},
		error => {
			if (onError) onError(error);
			else console.log(error);
		},
		() => {}
	)
		.retry()
		.subscribe();
};

Rx.Observable.prototype.option = function(text, options, callback) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var t = Helper.getValue(msg, text);
					var o = Helper.getValue(msg, options);

					t += "\n```";
					for (var i = 0; i < o.length; i++) {
						var optionText = null;
						if (o[i].name) optionText = o[i].name;
						else optionText = o[i];

						t += i + 1 + ". " + optionText + "\n";
					}
					t += "```";

					var x = BotManager.get(msg.botId).ask(
						msg.channel,
						msg.user,
						t,
						text => true
					);
					x.subscribe(botMsg => {
						if (botMsg == "timed-out") {
							BotManager.get(msg.botId).reply(Language.TookTooLong);
						} else {
							var optionSelected = parseInt(botMsg.text, 10);

							if (isNaN(optionSelected)) {
								var selected = null;
								for (var i = 0; i < o.length; i++) {
									var optionText = null;
									if (o[i].name) optionText = o[i].name;
									else optionText = o[i];
									if (optionText.toLowerCase() == botMsg.text.toLowerCase()) {
										selected = o[i];
									}
								}
							} else {
								var selected = o[optionSelected - 1];
							}

							if (selected != null) {
								if (callback) {
									callback(msg, selected);
								} else {
									msg.option = optionSelected;
								}
								observer.onNext(msg);
							} else BotManager.get(msg.botId).reply(Language.Cancelling, msg);
						}
					});
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};


Rx.Observable.prototype.say = function(text, option) {
	assert.equal(
		false,
		text == null,
		"ask requires either a function or string parameter for the text to display"
	);

	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var o = Helper.getValue(msg, option);
					var defaults = {
						user: null,
						channel: null
					};
					Object.assign(defaults, o);
					var t = Helper.getValue(msg, text);
					BotManager.get(msg.botId).say(
						defaults.channel || msg.channel,
						t,
						defaults.user || msg.user
					);
					observer.onNext(msg);
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};



Rx.Observable.prototype.ask = function(question, option) {
	assert.equal(
		false,
		question == null,
		"ask requires either a function or string parameter for the text to display"
	);

	var defaults = {
		predicate: msg => true,
		user: null,
		channel: null
	};
	Object.assign(defaults, option);

	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var text = Helper.getValue(msg, question);
					var resp = BotManager.get(msg.botId).ask(
						defaults.channel || msg.channel,
						defaults.user || msg.user,
						text,
						defaults.predicate
					);
					resp.subscribe(resp => {
						if (resp == "timed-out") {
							BotManager.get(msg.botId).reply(Language.TookTooLong, msg);
						} else {
							if (defaults.then) defaults.then(msg, resp.text);
							else msg.ask = resp.text;
							observer.onNext(msg);
						}
					});
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};

Rx.Observable.prototype.confirm = function(text) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					if (!text) text = Language.AreYouSure;

					var question =
						Helper.getValue(msg, text) +
						" (" +
						Language.Yes +
						"/" +
						Language.No +
						")";
					var resp = BotManager.get(msg.botId).ask(
						msg.channel,
						msg.user,
						question
					);

					resp.subscribe(m => {
						if (m == "timed-out") {
							BotManager.get(msg.botId).reply(Language.TookTooLong, msg);
						} else {
							if (m.text.toLowerCase() == Language.Yes.toLowerCase())
								observer.onNext(msg);
							else BotManager.get(msg.botId).reply(Language.Cancelling, msg);
						}
					});
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};

Rx.Observable.prototype.reply = function(text) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var t = Helper.getValue(msg, text);

					var bot = BotManager.get(msg.botId);
					bot.reply(t, msg);

					observer.onNext(msg);
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};


Rx.Observable.prototype.replyDirect = function(text) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var t = Helper.getValue(msg, text);
					var bot = BotManager.get(msg.botId);
					bot.say(msg.user.name, t);
					observer.onNext(msg);
				} catch (e) {
					e.conversation = msg;
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};

Rx.Observable.prototype.throttleByUser = function(time) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.groupBy(m => m.user, m => m).subscribe(o => {
			o.throttle(time).subscribe(x => {
				observer.onNext(x);
			});
		});
	});
};

Rx.Observable.prototype.multicast = function(arrayFn, mapFn) {
	return this.selectMany(x =>
		Rx.Observable.from(arrayFn()).select(item => {
			var xclone = JSON.parse(JSON.stringify(x));
			xclone.__proto__ = x.prototype;
			mapFn(xclone, item);
			return xclone;
		})
	);
};

Rx.Observable.prototype.set = function(key, value) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var v = Helper.getValue(msg, value);
					var k = Helper.getValue(msg, key);
					BotManager.get(msg.botId).persistance.set(k, v);
					observer.onNext(msg);
				} catch (e) {
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};


Rx.Observable.prototype.assert = function(assertion, message) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var a = Helper.getValue(msg, assertion);
					var m = Helper.getValue(msg, message);

					if(a)
						observer.onNext(msg);
					else	
						BotManager.get(msg.botId).reply(m, msg);
				} catch (e) {
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};


Rx.Observable.prototype.get = function(key, resultFn) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					var k = Helper.getValue(msg, key);
					var value = BotManager.get(msg.botId).persistance.get(k);
					resultFn(msg, value);
					observer.onNext(msg);
				} catch (e) {
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};

Rx.Observable.prototype.delete = function(key, resultFn) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					BotManager.get(msg.botId).persistance.delete(key(msg));
					observer.onNext(msg);
				} catch (e) {
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};

Rx.Observable.prototype.invoke = function(key, resultFn) {
	var source = this;
	return Rx.Observable.create(observer => {
		return source.subscribe(
			msg => {
				try {
					BotManager.get(msg.botId).internal.onNext(msg);
				} catch (e) {
					observer.onError(e);
				}
			},
			observer.onError.bind(observer),
			observer.onCompleted.bind(observer)
		);
	});
};