from email.headerregistry import Address
from django.test import SimpleTestCase

from django_courriel.validation import (
    CourrielError,
    InvalidAddressError,
    InvalidRecipientsError,
    InvalidSenderError,
    ValidAddress,
    ValidAddressList,
)

# test data
valid_inputs = (
    ValidAddress('Boris Vian', 'boris', 'vian.jazz'),
    'antoine@saint-exupery.aero',
    Address('Savinien de Cyrano', 'savinien', 'cyrano.lune'),
    'Aimé Césaire <cesaire@cahiers.net>',
    'Victor Hugo <victor-hugo@les-misérables.fr>',
)

invalid_inputs = (
    Address(),
    Address('Charles Baudelaire'),
    Address('Charles', 'charles', 'les fleurs du mal'),
    'Vernon Sullivan',
    'simone@bovary',
)


class TestValidAddress(SimpleTestCase):

    def setUp(self) -> None:
        self.invalid_specs = [
            'boris@vian',
            'bad adress',
        ]

    def test_interface(self):
        """ respects parent email.headerregistry.Address interface """
        try:
            a = ValidAddress('Boris Vian', 'boris', 'vian.jazz')
            self.assertEqual(a.display_name, 'Boris Vian')
            self.assertEqual(a.addr_spec, 'boris@vian.jazz')
            self.assertEqual(a.username, 'boris')
            self.assertEqual(a.domain, 'vian.jazz')
            self.assertEqual(str(a), 'Boris Vian <boris@vian.jazz>')
        except Exception as e:
            self.fail(f"should not have raised {e}")
        with self.assertRaises(AttributeError):  # should not be mutable
            a.addr_spec = "<vernon@affreux.org>"

    def test_new(self):
        """ __new__ shall raise InvalidAddress errors """
        with self.assertRaises(InvalidAddressError):
            ValidAddress()
        with self.assertRaises(InvalidAddressError):
            ValidAddress('Simone Veil')
        with self.assertRaises(InvalidAddressError):
            ValidAddress(username='Simone Veil', domain='cafe.philo')
        with self.assertRaises(InvalidAddressError):
            ValidAddress(username='simone', domain='veil')
        # some more bad specs
        for spec in self.invalid_specs:
            with self.assertRaises(InvalidAddressError):
                ValidAddress(addr_spec=spec)

    def test_factory(self):
        """ builder from string or Address """
        # invalid cases
        inputs = self.invalid_specs + [None, Address()]
        for input in inputs:
            with self.assertRaises(InvalidAddressError):
                ValidAddress.factory(input)
        # valid cases
        try:
            a = ValidAddress.factory('antoine@saint-exupery.aero')
            self.assertEqual(a.addr_spec, 'antoine@saint-exupery.aero')
            a = ValidAddress.factory('"Victor Hugo" <hugo@miserables.paris>')
            self.assertEqual(a.display_name, 'Victor Hugo')
            self.assertEqual(a.addr_spec, 'hugo@miserables.paris')
            # from an address
            old = Address(display_name='Savinien de Cyrano', username='savinien', domain='cyrano.lune')
            a = ValidAddress.factory(old)
            self.assertEqual(str(a), 'Savinien de Cyrano <savinien@cyrano.lune>')
        except InvalidAddressError as e:
            self.fail(f"should not have raised {e}")


class TestValidAddressList(SimpleTestCase):

    def setUp(self) -> None:
        self.test_list = ValidAddressList()

    def test__init(self):
        # valid values
        try:
            ValidAddressList()
            ValidAddressList(['victor@hugo.paris', 'Aimé Césaire <cesaire@cahiers.net>'])
        except InvalidAddressError as e:
            self.fail(f"should not have raised {e}")
        # invalid values
        with self.assertRaises(InvalidAddressError):
            ValidAddressList(['invalid@address'])

    def test_append(self):
        # valid values
        try:
            for i in valid_inputs:
                self.test_list.append(i)
        except InvalidAddressError as e:
            self.fail(f"should not have raised {e} when appending {i}")
        # invalid values
        for i in invalid_inputs:
            with self.assertRaises(InvalidAddressError):
                self.test_list.append(i)
        # checking conversions
        for item in self.test_list:
            self.assertIsInstance(item, ValidAddress)

    def test_insert(self):
        for i in valid_inputs:
            try:
                self.test_list.insert(0, i)
            except InvalidAddressError as e:
                self.fail(f"should not have raised {e} when inserting {i}")
        for i in invalid_inputs:
            with self.assertRaises(InvalidAddressError):
                self.test_list.insert(0, i)
        # checking conversions
        for item in self.test_list:
            self.assertIsInstance(item, ValidAddress)

    def test_set_item(self):
        # cannot set item on empty list !?
        self.test_list = ValidAddressList(['virginie@subutex.livre'])
        for i in valid_inputs:
            try:
                self.test_list[0] = i
            except InvalidAddressError as e:
                self.fail(f"should not have raised {e} when inserting {i}")
        for i in invalid_inputs:
            with self.assertRaises(InvalidAddressError):
                self.test_list[0] = i
        # checking conversions
        for item in self.test_list:
            self.assertIsInstance(item, ValidAddress)

    def test_extend(self):
        try:
            self.test_list.extend(valid_inputs)
        except InvalidAddressError as e:
            self.fail(f"should not have raised {e} when extending {valid_inputs}")
        with self.assertRaises(InvalidAddressError):
            self.test_list.extend(invalid_inputs)