import './Workers.html';

let QUERY_LIMIT = 100;
let QUERY_LIMIT_INCREMENT = 100;
let PREFIX = "Workers.";

Tracker.autorun(function() {
	Meteor.subscribe("Workers");
});

Template.Workers.onCreated(function() {
	Session.set(PREFIX + "displayNewWorker", false);
	Session.set(PREFIX + "showHidden", false);
	Session.set(PREFIX + "queryLimit", QUERY_LIMIT);
});
Template.Workers.onRendered(function() {
	$(".tableContainer").mCustomScrollbar({
		scrollButtons: {enable:true},
		theme: "light-thick",
		scrollbarPosition: "outside",
		scrollEasing: "linear"
	});
});
Template.Workers.helpers({
	displayNewWorker: function() {
		return Session.get(PREFIX + "displayNewWorker");
	},
	workers: function() {
		let skipCount = Session.get(PREFIX + 'skipCount') || 0;
		let query = Session.get(PREFIX + 'searchQuery');
		let dbQuery = [];
		
		if(query) {
			_.each(_.keys(query), function(key) {
				if(_.isFunction(query[key])) dbQuery.push({[key]: query[key]});  //dbQuery[key] = query[key]();
				else if(_.isObject(query[key])) dbQuery.push({[key]: query[key]});  //dbQuery[key] = query[key];  //Will look something like: {$in: [xxx,xxx,xxx]}
				else if(_.isNumber(query[key])) dbQuery.push({[key]: query[key]});  //dbQuery[key] = query[key];
				else {
					//dbQuery[key] = {$regex: query[key], $options: 'i'};
					let searchValue = query[key];
					let searches = searchValue && searchValue.length > 0 ? searchValue.split(/\s+/) : undefined;
					
					for(let search of searches) {
						dbQuery.push({[key]: {$regex: '\\b' + search, $options: 'i'}});
					}
				}
			})
		}
		
		if(!Session.get(PREFIX + "showHidden")) {
			//Ignore any hidden elements by showing those not hidden, or those without the hidden field.
			dbQuery.push({$or: [{hidden: false}, {hidden: {$exists:false}}]});
		}
		
		dbQuery = dbQuery.length > 0 ? {$and: dbQuery} : {};
		Session.set(PREFIX + 'workerCount',  Meteor.collections.Workers.find(dbQuery).count());  //Always get a full count.
		return Meteor.collections.Workers.find(dbQuery, {limit: Session.get(PREFIX + "queryLimit"), skip: skipCount, sort: {order: 1}});
	},
	disableLoadMore: function() {
		return Session.get(PREFIX + 'workerCount') - (Session.get(PREFIX + 'skipCount') || 0) - Session.get(PREFIX + "queryLimit") <= 0;
	}
});
Template.Workers.events({
	'click .loadMoreLink': function(event, template) {
		event.preventDefault();
		Session.set(PREFIX + 'queryLimit', Session.get(PREFIX + "queryLimit") + QUERY_LIMIT_INCREMENT);
	},
	'click .newWorkerButton': function(event, template) {
		if(template.$('.newWorkerButton').hasClass('active')) {
			Session.set(PREFIX + 'displayNewWorker', false);
		}
		else {
			Session.set(PREFIX + 'displayNewWorker', true);
			Session.set(PREFIX + "editedWorker", undefined);  //Clear the edited worker so that only one editor is open at a time.
		}
		template.$('.newWorkerButton').toggleClass('active');
	},
	'change input[name="showHidden"]': function(event, template) {
		Session.set(PREFIX + "showHidden", $(event.target).prop('checked'));
	}
});

Template.WorkerSearch.events({
	"keyup .searchInput": _.throttle(function(event, template) {
		let searchQuery = Session.get(PREFIX + 'searchQuery') || {};
		let searchFields = Session.get(PREFIX + 'searchFields') || {};
		let searchValue = template.$('.searchInput').val();
		
		if(searchValue) {
			if(this.number) searchValue = parseFloat(searchValue);
			
			if(this.collection) {
				let ids = Meteor.collections[this.collection].find({[this.collectionQueryColumnName]: {$regex: searchValue, $options: 'i'}}, {fields: {[this.collectionResultColumnName]: 1}}).fetch();
				
				//Convert the ids to an array of ids instead of an array of objects containing an id.
				for(let i = 0; i < ids.length; i++) {ids[i] = ids[i]._id;}
				searchQuery[this.columnName] = {$in: ids};
				searchFields[this.columnName] = searchValue;
			}
			else {
				searchFields[this.columnName] = searchQuery[this.columnName] = searchValue;
			}
		}
		else {
			//Remove columns from the search query whose values are empty so we don't bother the database with them.
			delete searchQuery[this.columnName];
			delete searchFields[this.columnName];
		}
		
		Session.set(PREFIX + 'searchQuery', searchQuery);
		Session.set(PREFIX + 'searchFields', searchFields);
		Session.set(PREFIX + 'skipCount', 0);  //Reset the paging of the results.
	}, 500)
});
Template.WorkerSearch.helpers({
	searchValue: function() {
		let searchFields = Session.get(PREFIX + 'searchFields');
		
		return (searchFields && searchFields[this.columnName]) ? searchFields[this.columnName] : '';
	}
});

Template.Worker.helpers({
	workers: function() {
		let result = "";
		
		if(this.workers && this.workers.length > 0) {
			let workerNames = [];
			
			for(let i = 0; i < this.workers.length; i++) {
				let workerObject = Meteor.collections.Workers.findOne(this.workers[i]);
				
				if(workerObject && workerObject.name)
					workerNames.push(workerObject.name);
			}
			
			result = workerNames.join(", ");
		}
		
		return result;
	},
	editing: function() {
		let editedWorker = Session.get(PREFIX + "editedWorker");
		
		return editedWorker == this._id;
	},
	getRowClass: function() {
		return this.hidden ? "hidden" : this.deactivated ? "deactivated" : "";
	}
});
Template.Worker.events({
	"click .actionEdit": function(event, template) {
		Session.set(PREFIX + "editedWorker", this._id);
		Session.set(PREFIX + 'displayNewWorker', false);  //Ensure the new worker editor is closed.
		template.parentTemplate().$('.newWorkerButton').removeClass('active');
	},
	"click .actionRemove": function(event, template) {
		Meteor.call('deactivateWorker', this._id, function(error, result) {
			if(error) sAlert.error(error);
			else sAlert.success("Worker Deactivated");
		});
	},
	'click .actionActivate': function(event, template) {
		Meteor.call('reactivateWorker', this._id, function(error, result) {
			if(error) sAlert.error(error);
			else sAlert.success("Worker Reactivated");
		});
	},
	"click .actionShow": function(event, template) {
		Meteor.call('showWorker', this._id, function(error, result) {
			if(error) sAlert.error(error);
			else sAlert.success("Worker Visibility Enabled");
		});
	},
	'click .actionHide': function(event, template) {
		Meteor.call('hideWorker', this._id, function(error, result) {
			if(error) sAlert.error(error);
			else sAlert.success("Worker Visibility Disabled");
		});
	}
});


Template.WorkerEditor.onRendered(function() {
	this.$(".activitiesEditor").select2();
});
Template.WorkerEditor.helpers({
	activities: function() {
		let schema = Meteor.collections.Workers.simpleSchema();
		
		return schema.constants.activities;
	},
	activitySelected: function() {
		let activity = this;
		let worker = Template.parentData();
		
		return worker.activities && worker.activities.includes(activity) ? "selected" : "";
	}
});
Template.WorkerEditor.events({
	"click .editorCancel": function(event, template) {
		Session.set(PREFIX + "editedWorker", undefined);
		Session.set(PREFIX + 'displayNewWorker', false);
		template.parentTemplate().$('.newWorkerButton').removeClass('active');
	},
	"click .editorApply": function(event, template) {
		let name = template.$("input[name='name']").val().trim();
		let activities = template.$(".activitiesEditor").select2('data');
		let hourlyRate = template.$("input[name='hourlyRate']").val().trim();
		
		activities = activities.map((n)=>n.id);
		hourlyRate = Number(hourlyRate);
		
		if(Session.get(PREFIX + 'displayNewWorker')) {
			Meteor.call("createWorker", name, activities, hourlyRate, function(error, result) {
				if(error) sAlert.error(error);
				else {
					sAlert.success("Worker created.");
					Session.set(PREFIX + 'displayNewWorker', false);
					template.parentTemplate().$('.newWorkerButton').removeClass('active');
				}
			});
		}
		else {
			Meteor.call("updateWorker", this._id, name, activities, hourlyRate, function(error, result) {
				if(error) sAlert.error(error);
				else {
					sAlert.success("Worker updated.");
					Session.set(PREFIX + "editedWorker", undefined);
					template.parentTemplate().$('.newWorkerButton').removeClass('active');
				}
			});
		}
		
	}
});