# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

import os

import mimetypes

import string

from email import encoders

from email.charset import Charset

from email.utils import parseaddr

from email.mime.base import MIMEBase

DEFAULT_ENCODING = "utf-8"

VALUE_IS_EMAIL_ADDRESS = lambda v: '@' in v

def normalize_header(header):

    return string.capwords(header.lower(), '-')

class EncodingError(Exception):

    """Thrown when there is an encoding error."""

    pass

class MailBase(object):

    """MailBase is used as the basis of lamson.mail and contains the basics of

    encoding an email.  You actually can do all your email processing with this

    class, but it's more raw.

    """

    def __init__(self, items=()):

        self.headers = dict(items)

        self.parts = []

        self.body = None

        self.content_encoding = {'Content-Type': (None, {}),

                                 'Content-Disposition': (None, {}),

                                 'Content-Transfer-Encoding': (None, {})}

        indicates the file name.

        """

        assert filename, "You can't attach a file without a filename."

        ctype = ctype.lower()

        part = MailBase()

        part.body = data

        part.content_encoding['Content-Type'] = (ctype, {'name': filename})

        part.content_encoding['Content-Disposition'] = (disposition,

                                                        {'filename': filename})

        self.parts.append(part)

    def attach_text(self, data, ctype):

        """

        This attaches a simpler text encoded part, which doesn't have a

        filename.

        """

        ctype = ctype.lower()

        part = MailBase()

        part.body = data

        part.content_encoding['Content-Type'] = (ctype, {})

        self.parts.append(part)

    def walk(self):

        for p in self.parts:

            yield p

            for x in p.walk():

                yield x

class MailResponse(object):

    """

    You are given MailResponse objects from the lamson.view methods, and

    whenever you want to generate an email to send to someone.  It has the

    same basic functionality as MailRequest, but it is designed to be written

    to, rather than read from (although you can do both).

    You can easily set a Body or Html during creation or after by passing it

    as __init__ parameters, or by setting those attributes.

    You can initially set the From, To, and Subject, but they are headers so

    use the dict notation to change them: msg['From'] = 'joe@test.com'.

        self.multipart = True

        if filename and not content_type:

            content_type, encoding = mimetypes.guess_type(filename)

        assert content_type, ("No content type given, and couldn't guess "

                              "from the filename: %r" % filename)

        self.attachments.append({'filename': filename,

                                 'content_type': content_type,

                                 'data': data,

                                 'disposition': disposition,})

    def attach_part(self, part):

        """

        Attaches a raw MailBase part from a MailRequest (or anywhere)

        so that you can copy it over.

        """

        self.multipart = True

        self.attachments.append({'filename': None,

                                 'content_type': None,

                                 'data': None,

                                 'disposition': None,

                                 'part': part,

        self.base.content_encoding = mail_request.base.content_encoding.copy()

    def clear(self):

        """

        Clears out the attachments so you can redo them.  Use this to keep the

        headers for a series of different messages with different attachments.

        """

        del self.attachments[:]

        del self.base.parts[:]

        self.multipart = False

    def update(self, message):

        """

        Used to easily set a bunch of heading from another dict

        like object.

        """

        for k in message.keys():

            self.base[k] = message[k]

    def __str__(self):

        """

        Converts to a string.

        """

        return to_message(self.base, separator=self.separator)

    def all_parts(self):

        """

        Returns all the encoded parts.  Only useful for debugging

        or inspecting after calling to_message().

        """

        return self.base.parts

    def keys(self):

        return self.base.keys()

def to_message(mail, separator="; "):

    """

    Given a MailBase message, this will construct a MIMEPart

    that is canonicalized for use with the Python email API.

    """

    ctype, params = mail.content_encoding['Content-Type']

    if not ctype:

        if mail.parts:

            ctype = 'multipart/mixed'

        else:

            ctype = 'text/plain'

    else:

        if mail.parts:

            assert ctype.startswith(("multipart", "message")), \

                   "Content type should be multipart or message, not %r" % ctype

    # adjust the content type according to what it should be now

    mail.content_encoding['Content-Type'] = (ctype, params)

    try:

        out = MIMEPart(ctype, **params)

        raise EncodingError("Content-Type malformed, not allowed: %r; "

                            "%r (Python ERROR: %s" %

                            (ctype, params, exc.message))

    for k in mail.keys():

        if k in ADDRESS_HEADERS_WHITELIST:

            out[k.encode('ascii')] = header_to_mime_encoding(

                                         mail[k],

                                         not_email=False,

                                         separator=separator

                                     )

        else:

    def add_text(self, content):

        # this is text, so encode it in canonical form

        try:

            encoded = content.encode('ascii')

            charset = 'ascii'

        except UnicodeError:

            encoded = content.encode('utf-8')

            charset = 'utf-8'

        self.set_payload(encoded, charset=charset)

    def extract_payload(self, mail):

        if mail.body == None: return  # only None, '' is still ok

        ctype, ctype_params = mail.content_encoding['Content-Type']

        cdisp, cdisp_params = mail.content_encoding['Content-Disposition']

        assert ctype, ("Extract payload requires that mail.content_encoding "

                       "have a valid Content-Type.")

        if ctype.startswith("text/"):

            self.add_text(mail.body)

        else: