import zope
from zope.event import notify

from zope.interface.common import idatetime

from BTrees.OOBTree import OOBTree

from Acquisition import aq_inner
from AccessControl.interfaces import IRoleManager

from Products.Five import BrowserView
from Products.Five.browser.pagetemplatefile import ZopeTwoPageTemplateFile
from Products.SecureMailHost.SecureMailHost import EMAIL_RE

from Products.CMFCore.utils import _checkPermission
from Products.CMFCore.utils import getToolByName

from Products.statusmessages.interfaces import IStatusMessage

from Products.listen.interfaces import IMailingList
from Products.listen.interfaces import IWriteMembershipList
from Products.listen.interfaces import IMembershipList
from Products.listen.interfaces import IMembershipPolicy
from Products.listen.interfaces import IMembershipPendingList
from Products.listen.interfaces import IUserTTWMembershipPolicy
from Products.listen.interfaces import IUserEmailMembershipPolicy

from Products.listen.content import archiveOptionsVocabulary

from Products.listen.lib.browser_utils import encode
from Products.listen.lib.common import assign_local_role
from Products.listen.permissions import SubscribeSelf

from Products.listen.i18n import _
from Products.listen.lib.common import is_email
from Products.listen.lib.common import lookup_email

from Products.listen.config import PROJECTNAME
from Products.listen.config import MEMBERSHIP_ALLOWED
from Products.listen.config import MEMBERSHIP_DEFERRED

from Products.listen.content import ListTypeChanged

from zope.component import getAdapter
from zope.app.annotation.interfaces import IAnnotations

from Products.listen.i18n import _

class MailingListView(BrowserView):
    """A basic view of a mailing list"""

    def __call__(self):
        sub_action = self.request.get('subscribe_member', None)
        unsub_action = self.request.get('unsubscribe_member', None)
        email_action = self.request.get('subscribe_email', None)
        self.request.set('enable_border', True)
        self.errors = errors = {}

        logged_in_mem = self._get_logged_in_user()
        self.user_logged_in = False
        if logged_in_mem:
            self.user_email = lookup_email(logged_in_mem.getId(), self.context)
            self.user_logged_in = True
        else:
            #XXX what should this be?
            self.user_email = ''

        self.mem_list = IWriteMembershipList(self.context)

        # the appropriate sub_policy needs to be instantiated
        # depending on list type
        self.sub_policy = getAdapter(self.context, IUserTTWMembershipPolicy)

        if sub_action:
            self.subscribe()
        elif unsub_action:
            self.unsubscribe()
        elif email_action:
            address = self.request.get('email_address', None)
            if not address:
                errors['email_address'] = _('An email address is required')
            elif EMAIL_RE.match(address) is None:
                errors['email_address'] = _('This email address is invalid')
            elif self.mem_list.is_subscribed(address):
                errors['email_address'] = \
                                 _('This email address is already subscribed')
            else:
                # everything is OK, send a request mail the
                # appropriate sub_policy needs to be instantiated
                # depending on list type
                sub_policy_for_email = getAdapter(self.context, IUserEmailMembershipPolicy)

                ret = sub_policy_for_email.enforce({'email':address,
                                                    'subject':'subscribe'})
                if ret == MEMBERSHIP_ALLOWED:
                    # make user a subscriber
                    self.mem_list.subscribe(address)
                    self.request.set('portal_status_message', 'Email subscribed')
                elif ret == MEMBERSHIP_DEFERRED:
                    self.request.set('portal_status_message',
                                     'Subscription request sent')
                else:
                    self.request.set('portal_status_message', 'Bad email address')
                    
                # Blank the email field to avoid the postback
                self.request.set('email_address', '')

        return self.index()

    def Title(self):
        return encode(self.context.title, self.context)

    def Description(self):
        return encode(self.context.description, self.context)

    def address(self):
        return encode(self.context.mailto, self.context)

    def archived(self):
        archived = self.context.archived
        vocab = archiveOptionsVocabulary(self.context)
        return vocab.getTerm(archived).token + '. '
    
    def is_archived(self):
        return self.context._is_archived()

    def list_managers(self):
        managers = []
        creator = self.context.Creator()
        for manager in self.context.managers:
            if manager == creator:
                managers.append('%s (creator)' % manager)
            else:
                managers.append(manager)
        return managers

    def list_title(self):
        return self.context.Title()

    def list_type(self):
        list_type = self.context.list_type
        if list_type is None:
            return _(u'List Type not set')
        return '%s. %s' % (list_type.title, list_type.description)

    def subscribe_keyword(self):
        # Mailboxer stores the subject line keyword used for subscribing as
        # a property
        return self.context.getValueFor('subscribe')

    def unsubscribe_keyword(self):
        # Mailboxer stores the subject line keyword used for unsubscribing as
        # a property
        return self.context.getValueFor('unsubscribe')

    def subscribe(self):
        req = {'action':'subscribe', 'email':self.user_email}
        if self.user_logged_in:
            req['use_logged_in_user'] = True
        ret = self.sub_policy.enforce(req)
                                       
        if ret == MEMBERSHIP_ALLOWED:
            self.mem_list.subscribe(self.user_email)
            self.request.set('portal_status_message',
                             'You have been subscribed')
            pass
        elif ret == MEMBERSHIP_DEFERRED:
            self.request.set('portal_status_message',
                             'Your subscription request is pending moderation '
                             'by the list manager.')       

    def unsubscribe(self):
        self.mem_list.unsubscribe(self.user_email)
        self.request.set('portal_status_message', 'You have been unsubscribed')

    def _get_logged_in_user(self):
        mtool = getToolByName(self.context, 'portal_membership')
        return mtool.getAuthenticatedMember()

    def isSubscribed(self):
        if self.user_email:
            return self.mem_list.is_subscribed(self.user_email)
        else:
            return False

    def isPending(self):
        annot = IAnnotations(self.context)
        sub_mod_pending_list = getAdapter(self.context,
                                          IMembershipPendingList,
                                          'pending_sub_mod_email')

        return sub_mod_pending_list.is_pending(self.user_email)

    def canSubscribe(self):
        return _checkPermission(SubscribeSelf, self.context)

    def manager_email(self):
        return _(u'manager-email-prompt',
                 'Please direct inquiries about this list '
                 'to %s' % self.context.manager_email)


class MailingListArchiveView(BrowserView):
    """A basic view for the mailing list archive.
    """
    def name(self):
        return encode(self.context.title, self.context)
    
    def archive(self):
        return self.context.archive


from zope.formlib import form
from base import EditForm

from zope.app.form.browser import TextAreaWidget
from zope.app.form.browser import ASCIIWidget
from zope.app.form.browser import RadioWidget
from Products.listen.browser.listwidget.widget import DynamicListWidget


class DescriptionWidget(TextAreaWidget):
    width = 40
    height = 3


def create_radio_widget(field, request):
    return RadioWidget(field, field.vocabulary, request)

listen_form_fields = form.FormFields(IMailingList)
listen_form_fields['description'].custom_widget = DescriptionWidget
listen_form_fields['mailto'].custom_widget = ASCIIWidget
listen_form_fields['archived'].custom_widget = create_radio_widget
listen_form_fields['list_type'].custom_widget = create_radio_widget
listen_form_fields['managers'].custom_widget = DynamicListWidget


class MailingListAddForm(form.AddForm):
    """A form for adding MailingList objects.
    """
    form_fields = listen_form_fields
    
    portal_type = 'MailingList'

    label = _(u"Add Mailing List")

    def _assign_local_roles_to_managers(self, ml):
        assign_local_role('Owner', ml.managers, IRoleManager(ml))

    def createAndAdd(self, data):
        # use aq_inner, or else the obj will be wrapped in this view,
        # will screw up acquired security settings (esp. local roles)
        context = aq_inner(self.context)
        plone_utils = getToolByName(context, 'plone_utils')
        list_id = plone_utils.normalizeString(data['title'])

        context.invokeFactory(self.portal_type, list_id)
        list_ob = context._getOb(list_id)

        old_list_type = list_ob.list_type.list_marker
        new_list_type = data.get('list_type').list_marker

        form.applyChanges(list_ob, self.form_fields, data)

        # ensure correct role is set for users
        self._assign_local_roles_to_managers(list_ob)
        
        # XXX this ObjectCreatedEvent event would normally come before
        # the ObjectAddedEvent
        notify(zope.app.event.objectevent.ObjectCreatedEvent(list_ob))
        notify(ListTypeChanged(list_ob, old_list_type, new_list_type))
        self._finished_add = True

        status = IStatusMessage(self.request)
        status.addStatusMessage(_('Mailing list added.'), type=u'info')

        self._next_url = list_ob.absolute_url()

        return list_ob

    def nextURL(self):
        return self._next_url


class MailingListEditForm(EditForm):
    """A form for editing MailingList objects.
    """
    form_fields = listen_form_fields

    label = _(u"Edit Mailing List")

    def _assign_local_roles_to_managers(self):
        ml = self.context
        assign_local_role('Owner', ml.managers, IRoleManager(ml))

    @form.action(_('label_save', u'Save'), condition=form.haveInputWidgets)
    def handle_save_action(self, action, data):
        old_list_type = self.context.list_type.list_marker
        new_list_type = data.get('list_type').list_marker

        if form.applyChanges(self.context, self.form_fields, data,
                             self.adapters):
            # ensure correct role is set for users
            self._assign_local_roles_to_managers()
            notify(zope.app.event.objectevent.ObjectModifiedEvent(self.context))
            notify(ListTypeChanged(self.context, old_list_type, new_list_type))
            self.status = _(u"Your changes have been saved.")
        else:
            self.status = _(u"No changes need to be saved.")
        return ""

    @form.action(_('label_cancel', u'Cancel'), validator=lambda *a: ())
    def handle_cancel_action(self, action, data):
        self.status = _(u"Edit cancelled.")
        return ""
