
'use strict';


define('forum/category/tools', [
	'topicSelect',
	'forum/topic/threadTools',
	'components',
	'api',
	'bootbox',
	'alerts',
	'bootstrap',
], function (topicSelect, threadTools, components, api, bootbox, alerts, bootstrap) {
	const CategoryTools = {};

	CategoryTools.init = function (containerEl) {
		topicSelect.init(updateDropdownOptions, () => {
			const toggleEl = document.querySelector('.thread-tools button');
			const dropdown = new bootstrap.Dropdown(toggleEl);
			dropdown.show();
		}, containerEl);

		handlePinnedTopicSort();

		$('[component="category/topic"]').each((index, el) => {
			threadTools.observeTopicLabels($(el).find('[component="topic/labels"]'));
		});

		components.get('topic/delete').on('click', function () {
			categoryCommand('del', '/state', 'delete', onDeleteRestoreComplete);
			return false;
		});

		components.get('topic/restore').on('click', function () {
			categoryCommand('put', '/state', 'restore', onDeleteRestoreComplete);
			return false;
		});

		components.get('topic/purge').on('click', function () {
			categoryCommand('del', '', 'purge', onPurgeComplete);
			return false;
		});

		components.get('topic/lock').on('click', function () {
			categoryCommand('put', '/lock', 'lock', onCommandComplete);
			return false;
		});

		components.get('topic/unlock').on('click', function () {
			categoryCommand('del', '/lock', 'unlock', onCommandComplete);
			return false;
		});

		components.get('topic/pin').on('click', function () {
			categoryCommand('put', '/pin', 'pin', onCommandComplete);
			return false;
		});

		components.get('topic/unpin').on('click', function () {
			categoryCommand('del', '/pin', 'unpin', onCommandComplete);
			return false;
		});

		// todo: should also use categoryCommand, but no write api call exists for this yet
		components.get('topic/mark-unread-for-all').on('click', function () {
			const tids = topicSelect.getSelectedTids();
			if (!tids.length) {
				return alerts.error('[[error:no-topics-selected]]');
			}
			socket.emit('topics.markAsUnreadForAll', tids, function (err) {
				if (err) {
					return alerts.error(err);
				}
				alerts.success('[[topic:markAsUnreadForAll.success]]');
				tids.forEach(function (tid) {
					$('[component="category/topic"][data-tid="' + tid + '"]').addClass('unread');
				});
				onCommandComplete();
			});
			return false;
		});

		components.get('topic/move').on('click', function () {
			require(['forum/topic/move'], function (move) {
				const tids = topicSelect.getSelectedTids();

				if (!tids.length) {
					return alerts.error('[[error:no-topics-selected]]');
				}
				move.init(tids, null, onCommandComplete);
			});

			return false;
		});

		components.get('topic/move-all').on('click', function () {
			const cid = ajaxify.data.cid;
			if (!ajaxify.data.template.category) {
				return alerts.error('[[error:invalid-data]]');
			}
			require(['forum/topic/move'], function (move) {
				move.init(null, cid, function (err) {
					if (err) {
						return alerts.error(err);
					}

					ajaxify.refresh();
				});
			});
		});

		components.get('topic/merge').on('click', function () {
			const tids = topicSelect.getSelectedTids();
			require(['forum/topic/merge'], function (merge) {
				merge.init(function () {
					if (tids.length) {
						tids.forEach(function (tid) {
							merge.addTopic(tid);
						});
					}
				});
			});
		});

		components.get('topic/tag').on('click', async function () {
			const tids = topicSelect.getSelectedTids();
			if (!tids.length) {
				return alerts.error('[[error:no-topics-selected]]');
			}
			const topics = await Promise.all(tids.map(tid => api.get(`/topics/${tid}`)));
			require(['forum/topic/tag'], function (tag) {
				tag.init(topics, ajaxify.data.tagWhitelist, onCommandComplete);
			});
		});

		CategoryTools.removeListeners();
		socket.on('event:topic_deleted', setDeleteState);
		socket.on('event:topic_restored', setDeleteState);
		socket.on('event:topic_purged', onTopicPurged);
		socket.on('event:topic_locked', setLockedState);
		socket.on('event:topic_unlocked', setLockedState);
		socket.on('event:topic_pinned', setPinnedState);
		socket.on('event:topic_unpinned', setPinnedState);
		socket.on('event:topic_moved', onTopicMoved);
	};

	function categoryCommand(method, path, command, onComplete) {
		if (!onComplete) {
			onComplete = function () {};
		}
		const tids = topicSelect.getSelectedTids();
		const body = {};
		const execute = function (ok) {
			if (ok) {
				Promise.all(tids.map(tid => api[method](`/topics/${tid}${path}`, body)))
					.then(onComplete)
					.catch(alerts.error);
			}
		};

		if (!tids.length) {
			return alerts.error('[[error:no-topics-selected]]');
		}

		switch (command) {
			case 'delete':
			case 'restore':
			case 'purge':
				bootbox.confirm(`[[topic:thread-tools.${command}-confirm]]`, execute);
				break;

			case 'pin':
				threadTools.requestPinExpiry(body, execute.bind(null, true));
				break;

			default:
				execute(true);
				break;
		}
	}

	CategoryTools.removeListeners = function () {
		socket.removeListener('event:topic_deleted', setDeleteState);
		socket.removeListener('event:topic_restored', setDeleteState);
		socket.removeListener('event:topic_purged', onTopicPurged);
		socket.removeListener('event:topic_locked', setLockedState);
		socket.removeListener('event:topic_unlocked', setLockedState);
		socket.removeListener('event:topic_pinned', setPinnedState);
		socket.removeListener('event:topic_unpinned', setPinnedState);
		socket.removeListener('event:topic_moved', onTopicMoved);
	};

	function closeDropDown() {
		$('.thread-tools .show').removeClass('show');
	}

	function onCommandComplete() {
		closeDropDown();
		topicSelect.unselectAll();
	}

	function onDeleteRestoreComplete() {
		closeDropDown();
		updateDropdownOptions();
	}

	function onPurgeComplete() {
		closeDropDown();
		topicSelect.unselectAll();
		updateDropdownOptions();
	}

	function updateDropdownOptions() {
		const tids = topicSelect.getSelectedTids();
		const isAnyDeleted = isAny(isTopicDeleted, tids);
		const areAllDeleted = areAll(isTopicDeleted, tids);
		const isAnyPinned = isAny(isTopicPinned, tids);
		const isAnyLocked = isAny(isTopicLocked, tids);
		const isAnyScheduled = isAny(isTopicScheduled, tids);
		const areAllScheduled = areAll(isTopicScheduled, tids);

		components.get('topic/delete').toggleClass('hidden', isAnyDeleted);
		components.get('topic/restore').toggleClass('hidden', isAnyScheduled || !isAnyDeleted);
		components.get('topic/purge').toggleClass('hidden', !areAllDeleted || !tids.length);

		components.get('topic/lock').toggleClass('hidden', isAnyLocked);
		components.get('topic/unlock').toggleClass('hidden', !isAnyLocked);

		components.get('topic/pin').toggleClass('hidden', areAllScheduled || isAnyPinned);
		components.get('topic/unpin').toggleClass('hidden', areAllScheduled || !isAnyPinned);

		components.get('topic/merge').toggleClass('hidden', isAnyScheduled);
	}

	function isAny(method, tids) {
		for (let i = 0; i < tids.length; i += 1) {
			if (method(tids[i])) {
				return true;
			}
		}
		return false;
	}

	function areAll(method, tids) {
		for (let i = 0; i < tids.length; i += 1) {
			if (!method(tids[i])) {
				return false;
			}
		}
		return true;
	}

	function isTopicDeleted(tid) {
		return getTopicEl(tid).hasClass('deleted');
	}

	function isTopicLocked(tid) {
		return getTopicEl(tid).hasClass('locked');
	}

	function isTopicPinned(tid) {
		return getTopicEl(tid).hasClass('pinned');
	}

	function isTopicScheduled(tid) {
		return getTopicEl(tid).hasClass('scheduled');
	}

	function getTopicEl(tid) {
		return components.get('category/topic', 'tid', tid);
	}

	function setDeleteState(data) {
		const topic = getTopicEl(data.tid);
		topic.toggleClass('deleted', data.isDeleted);
		topic.find('[component="topic/locked"]').toggleClass('hidden', !data.isDeleted);
	}

	function setPinnedState(data) {
		const topic = getTopicEl(data.tid);
		topic.toggleClass('pinned', data.isPinned);
		topic.find('[component="topic/pinned"]').toggleClass('hidden', !data.isPinned);
		ajaxify.refresh();
	}

	function setLockedState(data) {
		const topic = getTopicEl(data.tid);
		topic.toggleClass('locked', data.isLocked);
		topic.find('[component="topic/locked"]').toggleClass('hidden', !data.isLocked);
	}

	async function onTopicMoved(data) {
		if (ajaxify.data.template.category || String(data.toCid) === '-1') {
			getTopicEl(data.tid).remove();
		} else {
			const category = await api.get(`/categories/${data.toCid}`);
			const html = await app.parseAndTranslate('partials/topics_list', {
				topics: [{
					...data,
					category,
				}],
			});
			const categoryLabelSelector = `[component="category/topic"][data-tid="${data.tid}"] [component="topic/category"]`;
			$(categoryLabelSelector).replaceWith(html.find(categoryLabelSelector));
		}
	}

	function onTopicPurged(data) {
		getTopicEl(data.tid).remove();
	}

	function handlePinnedTopicSort() {
		if (!ajaxify.data.topics || !ajaxify.data.template.category) {
			return;
		}
		const numPinned = ajaxify.data.topics.filter(topic => topic.pinned).length;
		if ((!app.user.isAdmin && !app.user.isMod) || numPinned < 2) {
			return;
		}

		app.loadJQueryUI(function () {
			const topicListEl = $('[component="category"]').filter(function (i, e) {
				return !$(e).parents('[widget-area],[data-widget-area]').length;
			});
			let baseIndex = 0;
			topicListEl.sortable({
				axis: 'y',
				handle: '[component="topic/pinned"]',
				items: '[component="category/topic"].pinned',
				start: function () {
					baseIndex = parseInt(topicListEl.find('[component="category/topic"].pinned').first().attr('data-index'), 10);
				},
				update: function (ev, ui) {
					const tid = ui.item.attr('data-tid');
					const pinnedTopicEls = topicListEl.find('[component="category/topic"].pinned');
					let newIndex = 0;
					pinnedTopicEls.each((index, el) => {
						if ($(el).attr('data-tid') === tid) {
							newIndex = index;
							return false;
						}
					});

					socket.emit('topics.orderPinnedTopics', {
						tid: tid,
						order: baseIndex + newIndex,
					}, function (err) {
						if (err) {
							return alerts.error(err);
						}
						pinnedTopicEls.each((index, el) => {
							$(el).attr('data-index', baseIndex + index);
						});
					});
				},
			});
		});
	}

	return CategoryTools;
});
