import asyncore
import base64
import email
# from email.parser import Parser
from email.header import decode_header
import re
import signal
import smtpd
import socket
import threading
import time

from addresses import decodeAddress
from bmconfigparser import BMConfigParser
from debug import logger
from helper_sql import sqlExecute
from helper_ackPayload import genAckPayload
from helper_threading import StoppableThread
from pyelliptic.openssl import OpenSSL
import queues
from version import softwareVersion

SMTPDOMAIN = "bmaddr.lan"
LISTENPORT = 8425

class smtpServerChannel(smtpd.SMTPChannel):
    # def smtp_EHLO(self, arg):
    #     if not arg:
    #         self.push('501 Syntax: HELO hostname')
    #         return
    #     self.push('250-PyBitmessage %s' % softwareVersion)
    #     self.push('250 AUTH PLAIN')

    # def smtp_AUTH(self, arg):
    #     if not arg or arg[0:5] not in ["PLAIN"]:
    #         self.push('501 Syntax: AUTH PLAIN')
    #         return
    #     authstring = arg[6:]
    #     try:
    #         decoded = base64.b64decode(authstring)
    #         correctauth = "\x00" + BMConfigParser().safeGet("bitmessagesettings", "smtpdusername", "") + \
    #                 "\x00" + BMConfigParser().safeGet("bitmessagesettings", "smtpdpassword", "")
    #         logger.debug("authstring: %s / %s", correctauth, decoded)
    #         if correctauth == decoded:
    #             self.auth = True
    #             self.push('235 2.7.0 Authentication successful')
    #         else:
    #             raise Exception("Auth fail")
    #     except:
    #         self.push('501 Authentication fail')

    def smtp_DATA(self, arg):
        if not hasattr(self, "auth") or not self.auth:
            self.push ("530 Authentication required")
            return
        smtpd.SMTPChannel.smtp_DATA(self, arg)


class smtpServerPyBitmessage(smtpd.SMTPServer):
    def handle_accept(self):
        pair = self.accept()
        if pair is not None:
            conn, addr = pair
#            print >> DEBUGSTREAM, 'Incoming connection from %s' % repr(addr)
            # self.channel = smtpServerChannel(self, conn, addr)

    def send(self, fromAddress, toAddress, subject, message):
        status, addressVersionNumber, streamNumber, ripe = decodeAddress(toAddress)
        stealthLevel = BMConfigParser().safeGetInt('bitmessagesettings', 'ackstealthlevel')
        ackdata = genAckPayload(streamNumber, stealthLevel)
        t = ()
        sqlExecute(
            '''INSERT INTO sent VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
            '',
            toAddress,
            ripe,
            fromAddress,
            subject,
            message,
            ackdata,
            int(time.time()), # sentTime (this will never change)
            int(time.time()), # lastActionTime
            0, # sleepTill time. This will get set when the POW gets done.
            'msgqueued',
            0, # retryNumber
            'sent', # folder
            2, # encodingtype
            min(BMConfigParser().getint('bitmessagesettings', 'ttl'), 86400 * 2) # not necessary to have a TTL higher than 2 days
        )

        queues.workerQueue.put(('sendmessage', toAddress))

    def decode_header(self, hdr):
        ret = []
        for h in decode_header(self.msg_headers[hdr]):
            if h[1]:
                ret.append(unicode(h[0], h[1]))
            else:
                ret.append(h[0].decode("utf-8", errors='replace'))
            
        return ret


    # def process_message(self, peer, mailfrom, rcpttos, data):
#        print 'Receiving message from:', peer
        # p = re.compile(".*<([^>]+)>")
        # if not hasattr(self.channel, "auth") or not self.channel.auth:
        #     logger.error("Missing or invalid auth")
        #     return
        # try:
        #     self.msg_headers = Parser().parsestr(data)
        # except:
        #     logger.error("Invalid headers")
        #     return

        # try:
        #     sender, domain = p.sub(r'\1', mailfrom).split("@")
        #     if domain != SMTPDOMAIN:
        #         raise Exception("Bad domain %s", domain)
        #     if sender not in BMConfigParser().addresses():
        #         raise Exception("Nonexisting user %s", sender)
        # except Exception as err:
        #     logger.debug("Bad envelope from %s: %s", mailfrom, repr(err))
        #     msg_from = self.decode_header("from")
        #     try:
        #         msg_from = p.sub(r'\1', self.decode_header("from")[0])
        #         sender, domain = msg_from.split("@")
        #         if domain != SMTPDOMAIN:
        #             raise Exception("Bad domain %s", domain)
        #         if sender not in BMConfigParser().addresses():
        #             raise Exception("Nonexisting user %s", sender)
        #     except Exception as err:
        #         logger.error("Bad headers from %s: %s", msg_from, repr(err))
        #         return

        # try:
        #     msg_subject = self.decode_header('subject')[0]
        # except:
        #     msg_subject = "Subject missing..."

        # msg_tmp = email.message_from_string(data)
        # body = u''
        # for part in msg_tmp.walk():
        #     if part and part.get_content_type() == "text/plain":
        #         body += part.get_payload(decode=1).decode(part.get_content_charset('utf-8'), errors='replace')

        # for to in rcpttos:
        #     try:
        #         rcpt, domain = p.sub(r'\1', to).split("@")
        #         if domain != SMTPDOMAIN:
        #             raise Exception("Bad domain %s", domain)
        #         logger.debug("Sending %s to %s about %s", sender, rcpt, msg_subject)
        #         self.send(sender, rcpt, msg_subject, body)
        #         logger.info("Relayed %s to %s", sender, rcpt) 
        #     except Exception as err:
        #         logger.error( "Bad to %s: %s", to, repr(err))
        #         continue
        # return

class smtpServer(threading.Thread, StoppableThread):
    def __init__(self, parent=None):
        threading.Thread.__init__(self, name="smtpServerThread")
        self.initStop()
        self.server = smtpServerPyBitmessage(('127.0.0.1', LISTENPORT), None)
        
    def stopThread(self):
        super(smtpServer, self).stopThread()
        self.server.close()
        return
        # s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#        for ip in ('127.0.0.1', BMConfigParser().get('bitmessagesettings', 'onionbindip')):
        # for ip in ('127.0.0.1'):
        #     try:
        #         s.connect((ip, LISTENPORT))
        #         s.shutdown(socket.SHUT_RDWR)
        #         s.close()
        #         break
        #     except:
        #         pass

    def run(self):
        asyncore.loop(1)

def signals(signal, frame):
    print "Got signal, terminating"
    for thread in threading.enumerate():
        if thread.isAlive() and isinstance(thread, StoppableThread):
            thread.stopThread()

def runServer():
    print "Running SMTPd thread"
    smtpThread = smtpServer()
    smtpThread.start()
    signal.signal(signal.SIGINT, signals)
    signal.signal(signal.SIGTERM, signals)
    print "Processing"
    smtpThread.join()
    print "The end"

if __name__ == "__main__":
    runServer()