'use strict';

const _ = require('lodash');

const db = require('../database');
const topics = require('../topics');
const categories = require('../categories');
const user = require('../user');
const notifications = require('../notifications');
const plugins = require('../plugins');
const flags = require('../flags');

module.exports = function (Posts) {
	Posts.delete = async function (pid, uid) {
		return await deleteOrRestore('delete', pid, uid);
	};

	Posts.restore = async function (pid, uid) {
		return await deleteOrRestore('restore', pid, uid);
	};

	async function deleteOrRestore(type, pid, uid) {
		const isDeleting = type === 'delete';
		await plugins.hooks.fire(`filter:post.${type}`, { pid: pid, uid: uid });
		await Posts.setPostFields(pid, {
			deleted: isDeleting ? 1 : 0,
			deleterUid: isDeleting ? uid : 0,
		});
		const postData = await Posts.getPostFields(pid, ['pid', 'tid', 'uid', 'content', 'timestamp']);
		const topicData = await topics.getTopicFields(postData.tid, ['tid', 'cid', 'pinned']);
		postData.cid = topicData.cid;
		await Promise.all([
			topics.updateLastPostTimeFromLastPid(postData.tid),
			topics.updateTeaser(postData.tid),
			isDeleting ?
				db.sortedSetRemove(`cid:${topicData.cid}:pids`, pid) :
				db.sortedSetAdd(`cid:${topicData.cid}:pids`, postData.timestamp, pid),
		]);
		await categories.updateRecentTidForCid(postData.cid);
		plugins.hooks.fire(`action:post.${type}`, { post: _.clone(postData), uid: uid });
		if (type === 'delete') {
			await flags.resolveFlag('post', pid, uid);
		}
		return postData;
	}

	Posts.purge = async function (pids, uid) {
		pids = Array.isArray(pids) ? pids : [pids];
		let postData = await Posts.getPostsData(pids);
		pids = pids.filter((pid, index) => !!postData[index]);
		postData = postData.filter(Boolean);
		if (!postData.length) {
			return;
		}
		const uniqTids = _.uniq(postData.map(p => p.tid));
		const topicData = await topics.getTopicsFields(uniqTids, ['tid', 'cid', 'pinned', 'postcount']);
		const tidToTopic = _.zipObject(uniqTids, topicData);

		postData.forEach((p) => {
			p.topic = tidToTopic[p.tid];
			p.cid = tidToTopic[p.tid] && tidToTopic[p.tid].cid;
		});

		// deprecated hook
		await Promise.all(postData.map(p => plugins.hooks.fire('filter:post.purge', { post: p, pid: p.pid, uid: uid })));

		// new hook
		await plugins.hooks.fire('filter:posts.purge', {
			posts: postData,
			pids: postData.map(p => p.pid),
			uid: uid,
		});

		await Promise.all([
			deleteFromTopicUserNotification(postData),
			deleteFromCategoryRecentPosts(postData),
			deleteFromUsersBookmarks(pids),
			deleteFromUsersVotes(pids),
			deleteFromReplies(postData),
			deleteFromGroups(pids),
			deleteDiffs(pids),
			deleteFromUploads(pids),
			db.sortedSetsRemove(['posts:pid', 'posts:votes', 'posts:flagged'], pids),
			db.deleteAll(pids.map(pid => `pid:${pid}:editors`)),
		]);

		await resolveFlags(postData, uid);

		// deprecated hook
		Promise.all(postData.map(p => plugins.hooks.fire('action:post.purge', { post: p, uid: uid })));

		// new hook
		plugins.hooks.fire('action:posts.purge', { posts: postData, uid: uid });

		await db.deleteAll(postData.map(p => `post:${p.pid}`));
	};

	async function deleteFromTopicUserNotification(postData) {
		const bulkRemove = [];
		postData.forEach((p) => {
			bulkRemove.push([`tid:${p.tid}:posts`, p.pid]);
			bulkRemove.push([`tid:${p.tid}:posts:votes`, p.pid]);
			bulkRemove.push([`uid:${p.uid}:posts`, p.pid]);
			bulkRemove.push([`cid:${p.cid}:uid:${p.uid}:pids`, p.pid]);
			bulkRemove.push([`cid:${p.cid}:uid:${p.uid}:pids:votes`, p.pid]);
		});
		await db.sortedSetRemoveBulk(bulkRemove);

		const incrObjectBulk = [['global', { postCount: -postData.length }]];

		const postsByCategory = _.groupBy(postData, p => parseInt(p.cid, 10));
		for (const [cid, posts] of Object.entries(postsByCategory)) {
			incrObjectBulk.push([`category:${cid}`, { post_count: -posts.length }]);
		}

		const postsByTopic = _.groupBy(postData, p => parseInt(p.tid, 10));
		const topicPostCountTasks = [];
		const topicTasks = [];
		const zsetIncrBulk = [];
		const tids = [];
		for (const [tid, posts] of Object.entries(postsByTopic)) {
			tids.push(tid);
			incrObjectBulk.push([`topic:${tid}`, { postcount: -posts.length }]);
			if (posts.length && posts[0]) {
				const topicData = posts[0].topic;
				const newPostCount = topicData.postcount - posts.length;
				topicPostCountTasks.push(['topics:posts', newPostCount, tid]);
				if (!topicData.pinned) {
					zsetIncrBulk.push([`cid:${topicData.cid}:tids:posts`, -posts.length, tid]);
				}
			}
			topicTasks.push(topics.updateTeaser(tid));
			topicTasks.push(topics.updateLastPostTimeFromLastPid(tid));
			const postsByUid = _.groupBy(posts, p => parseInt(p.uid, 10));
			for (const [uid, uidPosts] of Object.entries(postsByUid)) {
				zsetIncrBulk.push([`tid:${tid}:posters`, -uidPosts.length, uid]);
			}
			topicTasks.push(db.sortedSetIncrByBulk(zsetIncrBulk));
		}

		await Promise.all([
			db.incrObjectFieldByBulk(incrObjectBulk),
			db.sortedSetAddBulk(topicPostCountTasks),
			...topicTasks,
			user.updatePostCount(_.uniq(postData.map(p => p.uid))),
			notifications.rescind(...postData.map(p => `new_post:tid:${p.tid}:pid:${p.pid}:uid:${p.uid}`)),
		]);
		const tidPosterZsets = tids.map(tid => `tid:${tid}:posters`);
		await db.sortedSetsRemoveRangeByScore(tidPosterZsets, '-inf', 0);
		const posterCounts = await db.sortedSetsCard(tidPosterZsets);
		await db.setObjectBulk(
			tids.map((tid, idx) => (
				[`topic:${tid}`, { postercount: posterCounts[idx] || 0 }]
			))
		);
	}

	async function deleteFromCategoryRecentPosts(postData) {
		const uniqCids = _.uniq(postData.map(p => p.cid));
		const sets = uniqCids.map(cid => `cid:${cid}:pids`);
		await db.sortedSetRemove(sets, postData.map(p => p.pid));
		await Promise.all(uniqCids.map(categories.updateRecentTidForCid));
	}

	async function deleteFromUsersBookmarks(pids) {
		const arrayOfUids = await db.getSetsMembers(pids.map(pid => `pid:${pid}:users_bookmarked`));
		const bulkRemove = [];
		pids.forEach((pid, index) => {
			arrayOfUids[index].forEach((uid) => {
				bulkRemove.push([`uid:${uid}:bookmarks`, pid]);
			});
		});
		await db.sortedSetRemoveBulk(bulkRemove);
		await db.deleteAll(pids.map(pid => `pid:${pid}:users_bookmarked`));
	}

	async function deleteFromUsersVotes(pids) {
		const [upvoters, downvoters] = await Promise.all([
			db.getSetsMembers(pids.map(pid => `pid:${pid}:upvote`)),
			db.getSetsMembers(pids.map(pid => `pid:${pid}:downvote`)),
		]);
		const bulkRemove = [];
		pids.forEach((pid, index) => {
			upvoters[index].forEach((upvoterUid) => {
				bulkRemove.push([`uid:${upvoterUid}:upvote`, pid]);
			});
			downvoters[index].forEach((downvoterUid) => {
				bulkRemove.push([`uid:${downvoterUid}:downvote`, pid]);
			});
		});

		await Promise.all([
			db.sortedSetRemoveBulk(bulkRemove),
			db.deleteAll([
				...pids.map(pid => `pid:${pid}:upvote`),
				...pids.map(pid => `pid:${pid}:downvote`),
			]),
		]);
	}

	async function deleteFromReplies(postData) {
		const arrayOfReplyPids = await db.getSortedSetsMembers(postData.map(p => `pid:${p.pid}:replies`));
		const allReplyPids = _.flatten(arrayOfReplyPids);
		const promises = [
			db.deleteObjectFields(
				allReplyPids.map(pid => `post:${pid}`), ['toPid']
			),
			db.deleteAll(postData.map(p => `pid:${p.pid}:replies`)),
		];

		const postsWithParents = postData.filter(p => parseInt(p.toPid, 10));
		const bulkRemove = postsWithParents.map(p => [`pid:${p.toPid}:replies`, p.pid]);
		promises.push(db.sortedSetRemoveBulk(bulkRemove));
		await Promise.all(promises);

		const parentPids = _.uniq(postsWithParents.map(p => p.toPid));
		const counts = await db.sortedSetsCard(parentPids.map(pid => `pid:${pid}:replies`));
		await db.setObjectBulk(parentPids.map((pid, index) => [`post:${pid}`, { replies: counts[index] }]));
	}

	async function deleteFromGroups(pids) {
		const groupNames = await db.getSortedSetMembers('groups:visible:createtime');
		const keys = groupNames.map(groupName => `group:${groupName}:member:pids`);
		await db.sortedSetRemove(keys, pids);
	}

	async function deleteDiffs(pids) {
		const timestamps = await Promise.all(pids.map(pid => Posts.diffs.list(pid)));
		await db.deleteAll([
			...pids.map(pid => `post:${pid}:diffs`),
			..._.flattenDeep(pids.map((pid, index) => timestamps[index].map(t => `diff:${pid}.${t}`))),
		]);
	}

	async function deleteFromUploads(pids) {
		await Promise.all(pids.map(Posts.uploads.dissociateAll));
	}

	async function resolveFlags(postData, uid) {
		const flaggedPosts = postData.filter(p => p && parseInt(p.flagId, 10));
		await Promise.all(flaggedPosts.map(p => flags.update(p.flagId, uid, { state: 'resolved' })));
	}
};
