from email.MIMEText import MIMEText
from email.Header import Header

from zope.interface import implements
from twisted.mail import smtp
from twisted.internet import reactor, defer, protocol

from twisted.trial.unittest import TestCase


def buildMessage(fromAddr, toAddr, subject, body):
    msg = MIMEText(body)
    msg['Subject'] = subject
    From = msg['From'] = fromAddr
    To = msg['To'] = toAddr
    return msg



def sendEmail(fromAddr, toAddr, message, smtpHost='localhost', smtpPort=25):
    messageData = message.as_string(unixfrom=False)
    return smtp.sendmail(smtpHost, fromAddr, [toAddr], messageData, port=smtpPort)



# This was taken (mostly) from page 124 of the Twisted book.
class CallbackMessageReceiver(object):
        implements(smtp.IMessage)

        def __init__(self, callback):
            # We separate the current lines we're using
            self.lines = []

            # from the full messages that we've received.
            self.callback = callback

        def lineReceived(self, line):
            print line
            self.lines.append(line)

        def eomReceived(self):
            # message is complete, tell everyone about it
            self.callback("\n".join(self.lines) + "\n")

            self.lines = []

            return defer.succeed(True)

        def connectionList(self):
            del (self.lines)



class CallbackMessageDelivery(object):
    implements(smtp.IMessageDelivery)

    def __init__(self, callback):
        self.callback = callback

    def receivedHeader(self, helo, origin, recipients):
        myHostname, clientIP = helo
        headerValue = "by %s from %s with ESMTP ; %s" % (
                myHostname, clientIP, smtp.rfc822date())
        return "Received: %s" % Header(headerValue)

    def validateTo(self, user):
        # Use the CallbackMessageReceiver to append messages to our
        # message list.
        return lambda: CallbackMessageReceiver(self.callback)

    def validateFrom(self, helo, originAddress):
        # Accept from anywhere.
        return originAddress



class DeferredSMTPFactory(protocol.ServerFactory):
    def __init__(self):
        self.listOfDeferreds = []

    def informDeferreds(self, result):
        # Tell everyone that was interested in knowing about this message
        for deferred in self.listOfDeferreds:
            deferred.callback(result)

        # Remove them from the list of listening deferreds.
        self.listOfDeferreds = []

    def messageReceived(self):
        d = defer.Deferred()
        self.listOfDeferreds.append(d)
        return d

    def buildProtocol(self, addr):
        delivery = CallbackMessageDelivery(self.informDeferreds)
        smtpProtocol = smtp.SMTP(delivery)
        smtpProtocol.factory = self
        return smtpProtocol



TEST_SMTP_PORT = 52125
class SMTPTests(TestCase):
    def setUp(self):
        self.deferredSMTP = DeferredSMTPFactory()
        self.smtpServer = reactor.listenTCP(TEST_SMTP_PORT, self.deferredSMTP)

    def tearDown(self):
        return self.smtpServer.stopListening()

    def test_sendingMessages(self):
        messageText = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit."
        subject = 'b-b-b-b-b-b-b-boilerplate!'
        toAddr = 'lakin@etsy.com'
        fromAddr = 'tabo@etsy.com'
        message = buildMessage(fromAddr, toAddr, subject, messageText)
        def finishedSending(receivedMessage):
            self.assertTrue(messageText in receivedMessage)
            print "Received -\n"
            print receivedMessage
            return receivedMessage

        emailSentDeferred = sendEmail(fromAddr, toAddr, message, smtpPort=TEST_SMTP_PORT)

        emailReceivedDeferred = self.deferredSMTP.messageReceived()
        emailReceivedDeferred.addCallback(finishedSending)

        return defer.DeferredList([emailSentDeferred, emailReceivedDeferred])