"""
SMTP server thread
"""
import asyncore
import base64
import email
import logging
import re
import signal
import smtpd
import threading
import time
from email.header import decode_header
from email.parser import Parser

import queues
from addresses import decodeAddress
from bmconfigparser import BMConfigParser
from helper_ackPayload import genAckPayload
from helper_sql import sqlExecute
from network.threads import StoppableThread
from version import softwareVersion

SMTPDOMAIN = "bmaddr.lan"
LISTENPORT = 8425

logger = logging.getLogger('default')
# pylint: disable=attribute-defined-outside-init


class smtpServerChannel(smtpd.SMTPChannel):
    """Asyncore channel for SMTP protocol (server)"""
    def smtp_EHLO(self, arg):
        """Process an EHLO"""
        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):
        """Process AUTH"""
        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):
        """Process DATA"""
        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):
    """Asyncore SMTP server class"""
    def handle_accept(self):
        """Accept a connection"""
        pair = self.accept()
        if pair is not None:
            conn, addr = pair
            self.channel = smtpServerChannel(self, conn, addr)

    def send(self, fromAddress, toAddress, subject, message):
        """Send a bitmessage"""
        # pylint: disable=arguments-differ
        streamNumber, ripe = decodeAddress(toAddress)[2:]
        stealthLevel = BMConfigParser().safeGetInt('bitmessagesettings', 'ackstealthlevel')
        ackdata = genAckPayload(streamNumber, stealthLevel)
        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
            # not necessary to have a TTL higher than 2 days
            min(BMConfigParser().getint('bitmessagesettings', 'ttl'), 86400 * 2)
        )

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

    def decode_header(self, hdr):
        """Email header decoding"""
        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):
        """Process an email"""
        # pylint: disable=too-many-locals, too-many-branches
        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: %r', mailfrom, 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: %r', msg_from, 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: %r', to, err)
                continue
        return


class smtpServer(StoppableThread):
    """SMTP server thread"""
    def __init__(self, _=None):
        super(smtpServer, self).__init__(name="smtpServerThread")
        self.server = smtpServerPyBitmessage(('127.0.0.1', LISTENPORT), None)

    def stopThread(self):
        super(smtpServer, self).stopThread()
        self.server.close()
        return

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


def signals(_, __):
    """Signal handler"""
    logger.warning('Got signal, terminating')
    for thread in threading.enumerate():
        if thread.isAlive() and isinstance(thread, StoppableThread):
            thread.stopThread()


def runServer():
    """Run SMTP server as a standalone python process"""
    logger.warning('Running SMTPd thread')
    smtpThread = smtpServer()
    smtpThread.start()
    signal.signal(signal.SIGINT, signals)
    signal.signal(signal.SIGTERM, signals)
    logger.warning('Processing')
    smtpThread.join()
    logger.warning('The end')


if __name__ == "__main__":
    runServer()