#!/usr/share/ucs-test/runner python
## desc: Test unionmap
## tags: [udm,apptest]
## roles: [domaincontroller_master]
## exposure: dangerous
## packages:
##   - univention-config
##   - univention-directory-manager-tools
##   - univention-mail-server

# pylint: disable=attribute-defined-outside-init

from __future__ import print_function
import time
import os
import dns.resolver
import tempfile
from essential.mail import send_mail, check_delivery, create_shared_mailfolder, imap_search_mail
from essential.mail import get_dovecot_maildir
from univention.testing.mail import MailSink, MailSinkGuard
from univention.testing.network import NetworkRedirector
import univention.testing.utils as utils
import univention.testing.udm as udm_test
import univention.testing.strings as uts
import univention.testing.ucr as ucr_test

TIMEOUT = 10

class Bunch(object):
	"""
	>>> y = Bunch(foo=42, bar='TEST')
	>>> print repr(y.foo), repr(y.bar)
	42 'TEST'

	>>> x = Bunch()
	>>> x.a = 4
	>>> print x.a
	4
	"""
	def __init__(self, **kwds):
		self.__dict__.update(kwds)

	def __str__(self):
		result = []
		for key, value in self.__dict__.iteritems():
			result.append('%s=%r' % (key, value))
		return 'Bunch(' + ', '.join(result) + ')'

	def __repr__(self):
		return str(self)


def random_user(mail_alternative_address=None):
	if mail_alternative_address is None:
		mail_alternative_address = '%s@%s' % (uts.random_string(), domain)
	user = Bunch()
	user.mailPrimaryAddress = '%s@%s' % (uts.random_string(), domain)
	user.mailAlternativeAddress = mail_alternative_address
	user.mailHomeServer = '%s.%s' % (ucr.get('hostname'), domain)
	user.dn, user.username = udm.create_user(set={
		'mailHomeServer': user.mailHomeServer,
		'mailPrimaryAddress': user.mailPrimaryAddress,
		'mailAlternativeAddress': user.mailAlternativeAddress,
	})
	return user


def imap_delivered_shared_folder(folder_name, msgid, token, user):
	fqdn = '%s.%s' % (ucr.get('hostname'), domain)
	for _ in range(TIMEOUT):
		try:
			found = imap_search_mail(messageid=msgid, server=fqdn, imap_user=user.mailPrimaryAddress,
									 imap_folder=folder_name, use_ssl=True)
		except AssertionError as exc:
			print(exc)
			found = False
		if found:
			print('Found mail in shared folder sent to %s' % (folder_name,))
			break
		time.sleep(1)
	if not found:
		utils.fail('Mail sent with token = %r to %s un-expectedly' % (token, folder_name))


if __name__ == '__main__':
	with ucr_test.UCSTestConfigRegistry() as ucr:
		with udm_test.UCSTestUDM() as udm:
			domain = ucr.get('domainname').lower()
			should_be_delivered = True

			# Case 1a) A mail to a@example.com is only delivered to user B but not to user A.
			# As expected: user b does receive the mail, user a doesn't receive the mail.
			a_user = random_user()
			b_user = random_user(mail_alternative_address=a_user.mailPrimaryAddress)
			token = str(time.time())
			send_mail(recipients=a_user.mailPrimaryAddress, msg=token, debuglevel=0)
			check_delivery(token, b_user.mailPrimaryAddress, should_be_delivered)
			# check_delivery(token, a_user.mailPrimaryAddress, should_be_delivered)

			# Case 1b) a group's mail is identical with a users mA.
			# -> All users receive a mail.
			group_mail = '%s@%s' % (uts.random_name(), domain)
			user_a = random_user(mail_alternative_address=group_mail)
			user_b = random_user()
			group_dn, group_name = udm.create_group(
				set={
					'mailAddress': group_mail,
					'users': [user_a.dn, user_b.dn]
				}
			)
			token = str(time.time())
			send_mail(recipients=group_mail, msg=token, debuglevel=0)
			check_delivery(token, user_a.mailPrimaryAddress, should_be_delivered)
			check_delivery(token, user_b.mailPrimaryAddress, should_be_delivered)

			# Case 1c: a mailing list's mail is identical with a users mA.
			# -> All users receive a mail.
			list_name = uts.random_name()
			mailing_list_mail = '%s@%s' % (list_name, domain)
			user_a = random_user(mail_alternative_address=mailing_list_mail)
			user_b = random_user()
			udm.create_object(
				'mail/lists',
				set={
					'name': list_name,
					'mailAddress': mailing_list_mail,
					'members': [user_a.mailPrimaryAddress, user_b.mailPrimaryAddress],
				}
			)
			token = str(time.time())
			send_mail(recipients=mailing_list_mail, msg=token, debuglevel=0)
			check_delivery(token, user_a.mailPrimaryAddress, should_be_delivered)
			check_delivery(token, user_b.mailPrimaryAddress, should_be_delivered)

			# Case 1d: A user has mail@shared_folder as mA address.
			# As expected: Mails are delivered to the user, but not to the shared folder.
			folder_name = uts.random_name()
			shared_folder_mail = '%s@%s' % (folder_name, domain)
			user = random_user(mail_alternative_address=shared_folder_mail)
			token = str(time.time())
			msgid = uts.random_name()
			fqdn = '%s.%s' % (ucr.get('hostname'), domain)
			folder_dn, folder_name, folder_mailaddress = create_shared_mailfolder(udm, fqdn, mailAddress=shared_folder_mail,
														 user_permission=['"%s" "%s"' % ('anyone', 'all')])
			path = get_dovecot_maildir(shared_folder_mail)
			assert os.path.exists(path), 'Maildir %r for shared folder with mail address does not exist! '
			send_mail(recipients=shared_folder_mail, msg=token, debuglevel=0, messageid=msgid)
			check_delivery(token, user.mailPrimaryAddress, should_be_delivered)
			imap_delivered_shared_folder(folder_name, msgid, token, user)

			# Case 2: When using a mailing list that sends mails to a group (with mail address),
			# no mail is delivered to the group members, at least because groups and distlists are different lookup tables.
			# -> All users receive a mail.
			group_members = []
			group_mails = []
			for i in range(2):
				user = random_user()
				group_members.append(user.dn)
				group_mails.append(user.mailPrimaryAddress)
			group_mail = '%s@%s' % (uts.random_string(), domain)
			group_dn, group_name = udm.create_group(
				set={
					'mailAddress': group_mail,
					'users': group_members
				}
			)
			list_name = uts.random_name()
			list_mail = '%s@%s' % (list_name, domain)
			udm.create_object(
				'mail/lists',
				set={
					'name': list_name,
					'mailAddress': list_mail,
					'members': group_mail,
				}
			)
			token = str(time.time())
			send_mail(recipients=list_mail, msg=token, debuglevel=0)
			for mail in group_mails:
				check_delivery(token, mail, should_be_delivered)