import { Language } from "./Language";
var Rx = require("rx").Rx;

export class Message {
	text: string;
	user: User;
	channel: string;
	privateMessage: boolean;
}

export class Context {
	botId: string;
	text: string;
	user: User;
	channel: string;

	constructor(botId: string, message: Message, params?) {
		this.botId = botId;
		this.text = message.text;
		this.user = message.user;
		this.channel = message.channel;

		if (params) {
			for (var p in params) {
				if (params.hasOwnProperty(p)) {
					if (this[p]) throw new Error("Invalid parameter name: " + p);
					this[p] = params[p];
				}
			}
		}
	}
}

export class BotMatch {
	match: string;
	observable: any;

	constructor(match: string) {
		this.match = match;
		this.observable = new Rx.Subject();
	}

	onNext(msg) {
		this.observable.onNext(msg);
	}
}

export class Helper {
	static isFunction(functionToCheck): boolean {
		var getType = {};
		return (
			functionToCheck &&
			getType.toString.call(functionToCheck) === "[object Function]"
		);
	}

	static getValue(msg, value): any {
		var result = null;
		if (Helper.isFunction(value)) {
			return value(msg);
		}
		return Helper.getRandom(value);
	}

	static getSynonym(input, fn) {
		var openBracketIdx = input.indexOf("(");

		if (openBracketIdx > -1) {
			var closedBracketIdx = input.indexOf(")");
			if (closedBracketIdx === -1) {
				console.log("uneven brackets");
				return input;
			}

			var match = input.substring(openBracketIdx, closedBracketIdx + 1);
			var innerMatch = match.substring(1, match.length - 1);
			var choose = fn(innerMatch.split("|"));

			return this.getSynonym(input.replace(match, choose), fn);
		} else {
			return input;
		}
	}

	static getRandom(input) {
		return Helper.getSynonym(input, x => {
			return x[Math.floor(Math.random() * x.length)];
		});
	}

	static getFirst(input) {
		return Helper.getSynonym(input, x => x[0]);
	}

	static getNamedParam(text) {
		let regex = /{([a-zA-Z_$][a-zA-Z_$0-9:|]*)}/;
		//let regex = /{(.*)}/;
		let o = text.match(regex);
		return o;
	}

	static getNamedParams(text) {
		var matches = [];
		var match = Helper.getNamedParam(text);
		while (match != null) {
			if (match[0].indexOf(":") > -1 && match[0].indexOf("|") > -1) {
				text = text.replace(match[0], "(" + match[1].split(":")[1] + ")");
				matches.push({ name: match[1], type: "string" });
			} else {
				text = text.replace(match[0], "(.*)");
				var t = match[1].split(":");
				if (t.length == 1) matches.push({ name: match[1], type: "string" });
				else matches.push({ name: t[0], type: t[1] });
			}
			match = Helper.getNamedParam(text);
		}

		return {
			text: text,
			matches: matches
		};
	}

	static setParametersOnObject(
		obj,
		replacedOriginal,
		stringMatchResult,
		botId
	) {
		if (stringMatchResult == null) return obj;
		for (var i = stringMatchResult.length - 1; i > 0; i--) {
			var currentMatch = stringMatchResult[i];
			if (replacedOriginal.matches[i - 1].type == "int") {
				currentMatch = parseInt(currentMatch, 10);
			} else if (replacedOriginal.matches[i - 1].type == "string") {
			} else if (replacedOriginal.matches[i - 1].type == "float") {
				currentMatch = parseFloat(currentMatch);
			} else if (replacedOriginal.matches[i - 1].type == "number") {
				currentMatch = parseFloat(currentMatch);
			} else if (replacedOriginal.matches[i - 1].type == "user") {
				currentMatch = BotManager.get(botId).getUserById(
					currentMatch.substring(2, currentMatch.length - 1)
				);
			} else {
			}

			obj[replacedOriginal.matches[i - 1].name] = currentMatch;
		}

		return obj;
	}

	static numberString(n) {
		if (n >= 0 && n < Language.Numbers.length) {
			return Language.Numbers[n];
		}
		return n;
	}
}

function uuidv4() {
	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
		var r = (Math.random() * 16) | 0,
			v = c == "x" ? r : (r & 0x3) | 0x8;
		return v.toString(16);
	});
}

export class User {
	id: string;
	name: string;
	displayName: string;
}

export class BotManager {
	static cache = {};
	static add(bot) {
		var id = uuidv4();
		BotManager.cache[id] = bot;
		return id;
	}
	static get(id) {
		if (!BotManager.cache[id]) throw new Error("Invalid bot id: " + id);
		return BotManager.cache[id];
	}
}

export interface IMessagingAdaptor {
	userProvider: IUserProvider;
	channelProvider: IChannelProvider;
	messageBus: IMessageBus;
	defaultChannel: string;
}

export interface IMessageBus {
	say(where, text, user): any;
	messages$: any;
}

export interface IUserProvider {
	getUsers(): User[];
	getUserById(id: string): User;
}

export interface IChannelProvider {
	getChannels(): string[];
}