import { escapeHTML } from '@rocket.chat/string-helpers';
import { Meteor } from 'meteor/meteor';

import { ltrim } from '../../../../../lib/utils/stringUtils';
import { callbacks } from '../../../../../server/lib/callbacks';
import { i18n } from '../../../../../server/lib/i18n';
import { roomCoordinator } from '../../../../../server/lib/rooms/roomCoordinator';
import * as Mailer from '../../../../mailer/server/api';
import { metrics } from '../../../../metrics/server';
import { settings } from '../../../../settings/server';
import { getURL } from '../../../../utils/server/getURL';

let advice = '';
let goToMessage = '';
Meteor.startup(() => {
	settings.watch('email_style', () => {
		goToMessage = Mailer.inlinecss('<p><a class=\'btn\' href="[room_path]">{Offline_Link_Message}</a></p>');
	});
	Mailer.getTemplate('Email_Footer_Direct_Reply', (value) => {
		advice = value;
	});
});

export async function getEmailContent({ message, user, room }) {
	const lng = (user && user.language) || settings.get('Language') || 'en';

	const roomName = escapeHTML(`#${await roomCoordinator.getRoomName(room.t, room)}`);
	const userName = escapeHTML(settings.get('UI_Use_Real_Name') ? message.u.name || message.u.username : message.u.username);

	const roomDirectives = roomCoordinator.getRoomDirectives(room.t);

	const header = i18n.t(!roomDirectives.isGroupChat(room) ? 'User_sent_a_message_to_you' : 'User_sent_a_message_on_channel', {
		username: userName,
		channel: roomName,
		lng,
	});

	if (message.t === 'e2e' && !message.file) {
		return settings.get('Email_notification_show_message') ? i18n.t('Encrypted_message_preview_unavailable', { lng }) : header;
	}

	if (message.msg !== '') {
		if (!settings.get('Email_notification_show_message')) {
			return header;
		}

		let messageContent = escapeHTML(message.msg);

		message = await callbacks.run('renderMessage', message);
		if (message.tokens && message.tokens.length > 0) {
			message.tokens.forEach((token) => {
				token.text = token.text.replace(/([^\$])(\$[^\$])/gm, '$1$$$2');
				messageContent = messageContent.replace(token.token, token.text);
			});
		}
		return `${header}:<br/><br/>${messageContent.replace(/\n/gm, '<br/>')}`;
	}

	if (message.file) {
		const fileHeader = i18n.t(!roomDirectives.isGroupChat(room) ? 'User_uploaded_a_file_to_you' : 'User_uploaded_a_file_on_channel', {
			username: userName,
			channel: roomName,
			lng,
		});

		if (!settings.get('Email_notification_show_message')) {
			return fileHeader;
		}

		let content = `${escapeHTML(message.file.name)}`;

		if (message.attachments && message.attachments.length === 1 && message.attachments[0].description !== '') {
			content += `<br/><br/>${escapeHTML(message.attachments[0].description)}`;
		}

		return `${fileHeader}:<br/><br/>${content}`;
	}

	if (!settings.get('Email_notification_show_message')) {
		return header;
	}

	if (Array.isArray(message.attachments) && message.attachments.length > 0) {
		const [attachment] = message.attachments;

		let content = '';

		if (attachment.title) {
			content += `${escapeHTML(attachment.title)}<br/>`;
		}
		if (attachment.text) {
			content += `${escapeHTML(attachment.text)}<br/>`;
		}

		return `${header}:<br/><br/>${content}`;
	}

	return header;
}

const getButtonUrl = (room, subscription, message) => {
	const basePath = roomCoordinator.getRouteLink(room.t, subscription).replace(Meteor.absoluteUrl(), '');

	const path = `${ltrim(basePath, '/')}?msg=${message._id}`;
	return getURL(
		path,
		{
			full: true,
			cloud: settings.get('Offline_Message_Use_DeepLink'),
			cloud_route: 'room',
			cloud_params: {
				rid: room._id,
				mid: message._id,
			},
		},
		settings.get('DeepLink_Url'),
	);
};

function generateNameEmail(name, email) {
	return `${String(name).replace(/@/g, '%40').replace(/[<>,]/g, '')} <${email}>`;
}

export async function getEmailData({ message, receiver, sender, subscription, room, emailAddress, hasMentionToUser }) {
	const username = settings.get('UI_Use_Real_Name') ? message.u.name || message.u.username : message.u.username;
	let subjectKey = 'Offline_Mention_All_Email';

	if (!roomCoordinator.getRoomDirectives(room.t).isGroupChat(room)) {
		subjectKey = 'Offline_DM_Email';
	} else if (hasMentionToUser) {
		subjectKey = 'Offline_Mention_Email';
	}

	const emailSubject = Mailer.replace(settings.get(subjectKey), {
		user: username,
		room: await roomCoordinator.getRoomName(room.t, room),
	});
	const content = await getEmailContent({
		message,
		user: receiver,
		room,
	});

	const room_path = getButtonUrl(room, subscription, message);

	const receiverName = settings.get('UI_Use_Real_Name') ? receiver.name || receiver.username : receiver.username;

	const email = {
		from: generateNameEmail(username, settings.get('From_Email')),
		to: generateNameEmail(receiverName, emailAddress),
		subject: emailSubject,
		html: content + goToMessage + (settings.get('Direct_Reply_Enable') ? advice : ''),
		data: {
			room_path,
		},
		headers: {},
	};

	if (sender.emails?.length > 0 && settings.get('Add_Sender_To_ReplyTo')) {
		const [senderEmail] = sender.emails;
		email.headers['Reply-To'] = generateNameEmail(username, senderEmail.address);
	}

	// If direct reply enabled, email content with headers
	if (settings.get('Direct_Reply_Enable')) {
		const replyto = settings.get('Direct_Reply_ReplyTo') || settings.get('Direct_Reply_Username');

		// Reply-To header with format "username+messageId@domain"
		email.headers['Reply-To'] = `${replyto.split('@')[0].split(settings.get('Direct_Reply_Separator'))[0]}${settings.get(
			'Direct_Reply_Separator',
		)}${message.tmid || message._id}@${replyto.split('@')[1]}`;
	}

	metrics.notificationsSent.inc({ notification_type: 'email' });
	return email;
}

export function sendEmailFromData(data) {
	metrics.notificationsSent.inc({ notification_type: 'email' });
	return Mailer.send(data);
}

export function shouldNotifyEmail({
	disableAllMessageNotifications,
	statusConnection,
	emailNotifications,
	isHighlighted,
	hasMentionToUser,
	hasMentionToAll,
	hasReplyToThread,
	roomType,
	isThread,
}) {
	// email notifications are disabled globally
	if (!settings.get('Accounts_AllowEmailNotifications')) {
		return false;
	}

	// user/room preference to nothing
	if (emailNotifications === 'nothing') {
		return false;
	}

	// user connected (don't need to send him an email)
	if (statusConnection === 'online') {
		return false;
	}

	// no user or room preference
	if (emailNotifications == null) {
		if (disableAllMessageNotifications && !isHighlighted && !hasMentionToUser && !hasReplyToThread) {
			return false;
		}

		// default server preference is disabled
		if (settings.get('Accounts_Default_User_Preferences_emailNotificationMode') === 'nothing') {
			return false;
		}
	}

	return (
		(roomType === 'd' ||
			isHighlighted ||
			emailNotifications === 'all' ||
			hasMentionToUser ||
			(!disableAllMessageNotifications && hasMentionToAll)) &&
		(isHighlighted || !isThread || hasReplyToThread)
	);
}