# -*- coding: UTF-8 -*-
# Copyright (c) 2007 - 2010, Pascal Volk
# See COPYING for distribution information.

"""
    VirtualMailManager.Alias

    Virtual Mail Manager's Alias class to manage e-mail aliases.
"""

from VirtualMailManager.Domain import Domain
from VirtualMailManager.EmailAddress import EmailAddress
from VirtualMailManager.Exceptions import VMMAliasException as VMMAE
from VirtualMailManager.constants.ERROR import ALIAS_ADDR_DEST_IDENTICAL, \
     ALIAS_EXCEEDS_EXPANSION_LIMIT, ALIAS_EXISTS, NO_SUCH_ALIAS, NO_SUCH_DOMAIN


_ = lambda msg: msg


class Alias(object):
    """Class to manage e-mail aliases."""
    __slots__ = ('_addr', '_dests', '_gid', '_dbh')

    def __init__(self, dbh, address):
        if isinstance(address, EmailAddress):
            self._addr = address
        else:
            raise TypeError("Argument 'address' is not an EmailAddress")
        self._dbh = dbh
        self._gid = 0
        self._dests = []

        self.__set_gid()
        self.__load_dests()

    def __set_gid(self):
        """Sets the alias' _gid based on its _addr.domainname."""
        dom = Domain(self._dbh, self._addr.domainname)
        self._gid = dom.getID()
        if self._gid == 0:
            raise VMMAE(_(u"The domain “%s” doesn't exist.") %
                        self._addr.domainname, NO_SUCH_DOMAIN)

    def __load_dests(self):
        """Loads all known destination addresses into the _dests list."""
        dbc = self._dbh.cursor()
        dbc.execute(
                'SELECT destination FROM alias WHERE gid=%s AND address=%s',
                    self._gid, self._addr.localpart)
        dests = iter(dbc.fetchall())
        if dbc.rowcount > 0:
            dest_add = self._dests.append
            for dest in dests:
                dest_add(EmailAddress(dest[0]))
        dbc.close()

    def __check_expansion(self, limit):
        """Checks the current expansion limit of the alias."""
        dcount = len(self._dests)
        failed = False
        if dcount == limit:
            failed = True
            errmsg = _(
u"""Can't add new destination to alias “%(address)s”.
Currently this alias expands into %(count)i/%(limit)i recipients.
One more destination will render this alias unusable.
Hint: Increase Postfix' virtual_alias_expansion_limit""")
        elif dcount > limit:
            failed = True
            errmsg = _(
u"""Can't add new destination to alias “%(address)s”.
This alias already exceeds it's expansion limit (%(count)i/%(limit)i).
So its unusable, all messages addressed to this alias will be bounced.
Hint: Delete some destination addresses.""")
        if failed:
            raise VMMAE(errmsg % {'address': self._addr, 'count': dcount,
                                  'limit': limit},
                        ALIAS_EXCEEDS_EXPANSION_LIMIT)

    def __delete(self, destination=None):
        """Deletes a destination from the alias, if ``destination`` is not
        ``None``. If ``destination`` is None, the alias with all it's
        destination addresses will be deleted."""
        dbc = self._dbh.cursor()
        if destination is None:
            dbc.execute("DELETE FROM alias WHERE gid=%s AND address=%s",
                        self._gid, self._addr.localpart)
        else:
            dbc.execute("DELETE FROM alias WHERE gid=%s AND address=%s AND \
 destination=%s",
                        self._gid, self._addr.localpart, str(destination))
        if dbc.rowcount > 0:
            self._dbh.commit()
        dbc.close()

    def __len__(self):
        """Returns the number of destinations of the alias."""
        return len(self._dests)

    def addDestination(self, destination, expansion_limit):
        """Adds the ``destination`` `EmailAddress` to the alias."""
        if not isinstance(destination, EmailAddress):
            raise TypeError("Argument 'destination' is not an EmailAddress")
        if self._addr == destination:
            raise VMMAE(_(u"Address and destination are identical."),
                        ALIAS_ADDR_DEST_IDENTICAL)
        if not destination in self._dests:
            self.__check_expansion(expansion_limit)
            dbc = self._dbh.cursor()
            dbc.execute('INSERT INTO alias (gid, address, destination) \
VALUES (%s, %s, %s)',
                        self._gid, self._addr.localpart, str(destination))
            self._dbh.commit()
            dbc.close()
            self._dests.append(destination)
        else:
            raise VMMAE(_(
                u'The alias “%(a)s” has already the destination “%(d)s”.') %
                        {'a': self._addr, 'd': destination}, ALIAS_EXISTS)

    def delDestination(self, destination):
        """Deletes the specified ``destination`` address from the alias."""
        if not isinstance(destination, EmailAddress):
            raise TypeError("Argument 'destination' is not an EmailAddress")
        if not self._dests:
            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,
                        NO_SUCH_ALIAS)
        if not destination in self._dests:
            raise VMMAE(_(u"The address “%(d)s” isn't a destination of \
the alias “%(a)s”.") %
                        {'a': self._addr, 'd': destination}, NO_SUCH_ALIAS)
        self.__delete(destination)
        self._dests.remove(destination)

    def getDestinations(self):
        """Returns an iterator for all destinations of the alias."""
        if self._dests:
            return iter(self._dests)
        else:
            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,
                        NO_SUCH_ALIAS)

    def delete(self):
        """Deletes the alias with all it's destinations."""
        if self._dests:
            self.__delete()
            del self._dests[:]
        else:
            raise VMMAE(_(u"The alias “%s” doesn't exist.") % self._addr,
                        NO_SUCH_ALIAS)


del _