#!/usr/bin/env python
# encoding: utf-8
"""
You can use this class for render and send html email message with the same
logic and facility of website page creation. Just create an html template file
with the same name of Class in lowercase.
"""

from django.core.mail import EmailMessage
from django.template.loader import render_to_string
from django.template import TemplateDoesNotExist
from django.contrib.auth.models import User
from django.contrib.sites.models import Site
from django.utils.translation import ugettext as _

class EmailError(Exception): pass

class JibEmailMessage(EmailMessage):

    context = {
        "site": Site.objects.get_current(),
    }
    subject = _("Message from portal")
    to_admins = False
    
    def __init__(self, recipient=None, headers={}, *args, **kwargs):
        _subject = self.subject
        super(JibEmailMessage, self).__init__(headers=headers, *args, **kwargs)
        self.subject = _subject
        self._set_recipient(recipient)
        self.headers = headers
    
    def _render_body(self):
        """this method render template file with the same name of class and return rendered text"""
        
        # this method i availabled only for inherited classes
        if self.__class__ != JibEmailMessage:
            
            # search file with class name in lowercase in email directory
            body_template = "email/%s.html" % (self.__class__.__name__.lower(),)
            try:
                # render_to_string is django function for rendering template from
                # file. self.context is a dict with variables that will be rendered
                # in email body
                self.body = render_to_string(body_template,self.context)
            except TemplateDoesNotExist,e:
                raise EmailError(e)
        else:
            raise EmailError("You can't render JibEmailMessage parent class")
    
    def _set_recipient(self, recipient):
        """Set the email recipient fetching email address from django user instance"""
        if recipient and isinstance(recipient, User):
            self.to.append(recipient.email)
            self.recipient = recipient
            return
        # if True the email will send to MANAGERS set in django settings
        if self.to_admins:
            for manager in MANAGERS:
                self.to.append(manager[1])            
            return
        raise EmailError("Only Django User instance accepted")

    def retrieve_recipient_info(self): 
        """This method is for inherited classes"""
        pass
        
    def send(self, *args, **kwargs):
        """
        This is a redefinition of parent class EmailMessage send method. Before sending data,
        i need to update context dict and render email body
        """
        self.retrieve_recipient_info()
        self._render_body()
        if self.body:
            return super(JibEmailMessage,self).send(*args, **kwargs)
    
    def message(self, *args, **kwargs):
        """
        This is a redefinition of parent class EmailMessage message method. Before showing data,
        i need to update context dict and render email body
        """
        self.retrieve_recipient_info()
        self._render_body()
        return super(JibEmailMessage,self).message(*args, **kwargs)

# EXAMPLES        
        
class SignupActivationEmail(JibEmailMessage): 
    
    subject = _("Activate Your Account")
    
    def __init__(self, recipient, token, *args, **kwargs):
        super(SignupActivationEmail, self).__init__(recipient, *args, **kwargs)
        self.token = token
        
    def retrieve_recipient_info(self):
        self.context.update({
            "username": self.recipient.username,
            "token": self.token,
        })
        
        
class ContactUserEmail(JibEmailMessage): 
    
    subject = _("Message from %s")
    
    def __init__(self, sender, recipient, message, time, headers={}, *args, **kwargs):
        super(ContactUserEmail, self).__init__(recipient, headers, *args, **kwargs)
        self.sender = sender
        self.context.update({
            "message":message,
            "time":time,
        })
        
    def retrieve_recipient_info(self):
        if "%s" in  self.subject:
            self.subject = self.subject % self.sender.username
        self.context.update({
            "username": self.sender.username,
        })