import type { IEditedMessage, IMessage, IRoom, ISubscription } from '@rocket.chat/core-typings';
import { Random } from '@rocket.chat/random';
import moment from 'moment';

import { hasAtLeastOnePermission, hasPermission } from '../../../app/authorization/client';
import { Messages, ChatRoom, ChatSubscription } from '../../../app/models/client';
import { settings } from '../../../app/settings/client';
import { readMessage, MessageTypes } from '../../../app/ui-utils/client';
import { sdk } from '../../../app/utils/client/lib/SDKClient';
import { onClientBeforeSendMessage } from '../onClientBeforeSendMessage';
import { prependReplies } from '../utils/prependReplies';
import type { DataAPI } from './ChatAPI';

export const createDataAPI = ({ rid, tmid }: { rid: IRoom['_id']; tmid: IMessage['_id'] | undefined }): DataAPI => {
	const composeMessage = async (
		text: string,
		{ sendToChannel, quotedMessages, originalMessage }: { sendToChannel?: boolean; quotedMessages: IMessage[]; originalMessage?: IMessage },
	): Promise<IMessage> => {
		const msg = await prependReplies(text, quotedMessages);

		const effectiveRID = originalMessage?.rid ?? rid;
		const effectiveTMID = originalMessage ? originalMessage.tmid : tmid;

		return (await onClientBeforeSendMessage({
			_id: originalMessage?._id ?? Random.id(),
			rid: effectiveRID,
			...(effectiveTMID && {
				tmid: effectiveTMID,
				...(sendToChannel && { tshow: sendToChannel }),
			}),
			msg,
		})) as IMessage;
	};

	const findMessageByID = async (mid: IMessage['_id']): Promise<IMessage | null> =>
		Messages.findOne({ _id: mid, _hidden: { $ne: true } }, { reactive: false }) ?? sdk.call('getSingleMessage', mid);

	const getMessageByID = async (mid: IMessage['_id']): Promise<IMessage> => {
		const message = await findMessageByID(mid);

		if (!message) {
			throw new Error('Message not found');
		}

		return message;
	};

	const findLastMessage = async (): Promise<IMessage | undefined> =>
		Messages.findOne({ rid, tmid: tmid ?? { $exists: false }, _hidden: { $ne: true } }, { sort: { ts: -1 }, reactive: false });

	const getLastMessage = async (): Promise<IMessage> => {
		const message = await findLastMessage();

		if (!message) {
			throw new Error('Message not found');
		}

		return message;
	};

	const findLastOwnMessage = async (): Promise<IMessage | undefined> => {
		const uid = Meteor.userId();

		if (!uid) {
			return undefined;
		}

		return Messages.findOne(
			{ rid, 'tmid': tmid ?? { $exists: false }, 'u._id': uid, '_hidden': { $ne: true } },
			{ sort: { ts: -1 }, reactive: false },
		);
	};

	const getLastOwnMessage = async (): Promise<IMessage> => {
		const message = await findLastOwnMessage();

		if (!message) {
			throw new Error('Message not found');
		}

		return message;
	};

	const canUpdateMessage = async (message: IMessage): Promise<boolean> => {
		if (MessageTypes.isSystemMessage(message)) {
			return false;
		}

		const canEditMessage = hasAtLeastOnePermission('edit-message', message.rid);
		const editAllowed = (settings.get('Message_AllowEditing') as boolean | undefined) ?? false;
		const editOwn = message?.u && message.u._id === Meteor.userId();

		if (!canEditMessage && (!editAllowed || !editOwn)) {
			return false;
		}

		const blockEditInMinutes = settings.get('Message_AllowEditing_BlockEditInMinutes') as number | undefined;
		const bypassBlockTimeLimit = hasPermission('bypass-time-limit-edit-and-delete');

		const elapsedMinutes = moment().diff(message.ts, 'minutes');
		if (!bypassBlockTimeLimit && elapsedMinutes && blockEditInMinutes && elapsedMinutes > blockEditInMinutes) {
			return false;
		}

		return true;
	};

	const findPreviousOwnMessage = async (message: IMessage): Promise<IMessage | undefined> => {
		const uid = Meteor.userId();

		if (!uid) {
			return undefined;
		}

		const msg = Messages.findOne(
			{ rid, 'tmid': tmid ?? { $exists: false }, 'u._id': uid, '_hidden': { $ne: true }, 'ts': { $lt: message.ts } },
			{ sort: { ts: -1 }, reactive: false },
		);

		if (!msg) {
			return undefined;
		}

		if (await canUpdateMessage(msg)) {
			return msg;
		}

		return findPreviousOwnMessage(msg);
	};

	const getPreviousOwnMessage = async (message: IMessage): Promise<IMessage> => {
		const previousMessage = await findPreviousOwnMessage(message);

		if (!previousMessage) {
			throw new Error('Message not found');
		}

		return previousMessage;
	};

	const findNextOwnMessage = async (message: IMessage): Promise<IMessage | undefined> => {
		const uid = Meteor.userId();

		if (!uid) {
			return undefined;
		}

		const msg = Messages.findOne(
			{ rid, 'tmid': tmid ?? { $exists: false }, 'u._id': uid, '_hidden': { $ne: true }, 'ts': { $gt: message.ts } },
			{ sort: { ts: 1 }, reactive: false },
		);

		if (!msg) {
			return undefined;
		}

		if (await canUpdateMessage(msg)) {
			return msg;
		}

		return findNextOwnMessage(msg);
	};

	const getNextOwnMessage = async (message: IMessage): Promise<IMessage> => {
		const nextMessage = await findNextOwnMessage(message);

		if (!nextMessage) {
			throw new Error('Message not found');
		}

		return nextMessage;
	};

	const pushEphemeralMessage = async (message: Omit<IMessage, 'rid' | 'tmid'>): Promise<void> => {
		Messages.upsert({ _id: message._id }, { $set: { ...message, rid, ...(tmid && { tmid }) } });
	};

	const updateMessage = async (message: IEditedMessage): Promise<void> => sdk.call('updateMessage', message);

	const canDeleteMessage = async (message: IMessage): Promise<boolean> => {
		const uid = Meteor.userId();

		if (!uid) {
			return false;
		}

		if (MessageTypes.isSystemMessage(message)) {
			return false;
		}

		const forceDeleteAllowed = hasPermission('force-delete-message', message.rid);
		if (forceDeleteAllowed) {
			return true;
		}

		const deletionEnabled = settings.get('Message_AllowDeleting') as boolean | undefined;
		if (!deletionEnabled) {
			return false;
		}

		const deleteAnyAllowed = hasPermission('delete-message', rid);
		const deleteOwnAllowed = hasPermission('delete-own-message');
		const deleteAllowed = deleteAnyAllowed || (deleteOwnAllowed && message?.u && message.u._id === Meteor.userId());

		if (!deleteAllowed) {
			return false;
		}

		const blockDeleteInMinutes = settings.get('Message_AllowDeleting_BlockDeleteInMinutes') as number | undefined;
		const bypassBlockTimeLimit = hasPermission('bypass-time-limit-edit-and-delete');
		const elapsedMinutes = moment().diff(message.ts, 'minutes');
		const onTimeForDelete = bypassBlockTimeLimit || !blockDeleteInMinutes || !elapsedMinutes || elapsedMinutes <= blockDeleteInMinutes;

		return deleteAllowed && onTimeForDelete;
	};

	const deleteMessage = async (mid: IMessage['_id']): Promise<void> => {
		await sdk.call('deleteMessage', { _id: mid });
		Messages.remove({ _id: mid });
	};

	const drafts = new Map<IMessage['_id'] | undefined, string>();

	const getDraft = async (mid: IMessage['_id'] | undefined): Promise<string | undefined> => drafts.get(mid);

	const discardDraft = async (mid: IMessage['_id'] | undefined): Promise<void> => {
		drafts.delete(mid);
	};

	const saveDraft = async (mid: IMessage['_id'] | undefined, draft: string): Promise<void> => {
		drafts.set(mid, draft);
	};

	const findRoom = async (): Promise<IRoom | undefined> => ChatRoom.findOne({ _id: rid }, { reactive: false });

	const getRoom = async (): Promise<IRoom> => {
		const room = await findRoom();

		if (!room) {
			throw new Error('Room not found');
		}

		return room;
	};

	const isSubscribedToRoom = async (): Promise<boolean> => !!ChatSubscription.findOne({ rid }, { reactive: false });

	const joinRoom = async (): Promise<void> => {
		await sdk.call('joinRoom', rid);
	};

	const markRoomAsRead = async (): Promise<void> => {
		readMessage.readNow(rid);
		readMessage.refreshUnreadMark(rid);
	};

	const findDiscussionByID = async (drid: IRoom['_id']): Promise<IRoom | undefined> =>
		ChatRoom.findOne({ _id: drid, prid: { $exists: true } }, { reactive: false });

	const getDiscussionByID = async (drid: IRoom['_id']): Promise<IRoom> => {
		const discussion = await findDiscussionByID(drid);

		if (!discussion) {
			throw new Error('Discussion not found');
		}

		return discussion;
	};

	const createStrictGetter = <TFind extends (...args: any[]) => Promise<any>>(
		find: TFind,
		errorMessage: string,
	): ((...args: Parameters<TFind>) => Promise<Exclude<Awaited<ReturnType<TFind>>, undefined>>) => {
		return async (...args) => {
			const result = await find(...args);

			if (!result) {
				throw new Error(errorMessage);
			}

			return result;
		};
	};

	const findSubscription = async (): Promise<ISubscription | undefined> => {
		return ChatSubscription.findOne({ rid }, { reactive: false });
	};

	const getSubscription = createStrictGetter(findSubscription, 'Subscription not found');

	const findSubscriptionFromMessage = async (message: IMessage): Promise<ISubscription | undefined> => {
		return ChatSubscription.findOne({ rid: message.rid }, { reactive: false });
	};

	const getSubscriptionFromMessage = createStrictGetter(findSubscriptionFromMessage, 'Subscription not found');

	return {
		composeMessage,
		findMessageByID,
		getMessageByID,
		findLastMessage,
		getLastMessage,
		findLastOwnMessage,
		getLastOwnMessage,
		findPreviousOwnMessage,
		getPreviousOwnMessage,
		findNextOwnMessage,
		getNextOwnMessage,
		pushEphemeralMessage,
		canUpdateMessage,
		updateMessage,
		canDeleteMessage,
		deleteMessage,
		getDraft,
		saveDraft,
		discardDraft,
		findRoom,
		getRoom,
		isSubscribedToRoom,
		joinRoom,
		markRoomAsRead,
		findDiscussionByID,
		getDiscussionByID,
		findSubscription,
		getSubscription,
		findSubscriptionFromMessage,
		getSubscriptionFromMessage,
	};
};