# -*- coding: utf-8 -*-

""" Email client """

import logging
import os
import smtplib
import email.utils
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.encoders import encode_base64

from mako.template import Template as MakoTemplate

log = logging.getLogger(__name__)


class EmailClient(object):  # pylint: disable=useless-object-inheritance,too-many-instance-attributes
    """
    Email client

    This class abstract all interactions with the SMTP server.
    """

    smtp_host = None
    smtp_port = None
    smtp_ssl = None
    smtp_tls = None
    smtp_user = None
    smtp_password = None
    smtp_debug = None

    sender_name = None
    sender_email = None

    catch_all_addr = False
    just_try = False

    encoding = 'utf-8'

    templates = dict()

    def __init__(self, smtp_host=None, smtp_port=None, smtp_ssl=None, smtp_tls=None, smtp_user=None, smtp_password=None, smtp_debug=None,
                 sender_name=None, sender_email=None, catch_all_addr=None, just_try=None, encoding=None, templates=None):
        self.smtp_host = smtp_host if smtp_host else 'localhost'
        self.smtp_port = smtp_port if smtp_port else 25
        self.smtp_ssl = bool(smtp_ssl)
        self.smtp_tls = bool(smtp_tls)
        self.smtp_user = smtp_user if smtp_user else None
        self.smtp_password = smtp_password if smtp_password else None
        self.smtp_debug = bool(smtp_debug)

        self.sender_name = sender_name if sender_name else "No reply"
        self.sender_email = sender_email if sender_email else "noreply@localhost"
        self.catch_all_addr = catch_all_addr if catch_all_addr else False
        self.just_try = just_try if just_try else False

        assert templates is None or isinstance(templates, dict)
        self.templates = templates if templates else dict()

        if encoding:
            self.encoding = encoding

    def forge_message(self, rcpt_to, subject=None, html_body=None, text_body=None, attachment_files=None,
                      attachment_payloads=None, sender_name=None, sender_email=None, encoding=None,
                      template=None, **template_vars):  # pylint: disable=too-many-arguments,too-many-locals
        """
        Forge a message

        :param rcpt_to:             The recipient of the email. Could be a tuple(name, email) or just the email of the recipient.
        :param subject:             The subject of the email.
        :param html_body:           The HTML body of the email
        :param text_body:           The plain text body of the email
        :param attachment_files:    List of filepaths to attach
        :param attachment_payloads: List of tuples with filename and payload to attach
        :param sender_name:         Custom sender name (default: as defined on initialization)
        :param sender_email:        Custom sender email (default: as defined on initialization)
        :param encoding:            Email content encoding (default: as defined on initialization)
        :param template:            The name of a template to use to forge this email

        All other parameters will be consider as template variables.
        """
        msg = MIMEMultipart('alternative')
        msg['To'] = email.utils.formataddr(rcpt_to) if isinstance(rcpt_to, tuple) else rcpt_to
        msg['From'] = email.utils.formataddr((sender_name or self.sender_name, sender_email or self.sender_email))
        if subject:
            msg['Subject'] = subject.format(**template_vars)
        msg['Date'] = email.utils.formatdate(None, True)
        encoding = encoding if encoding else self.encoding
        if template:
            assert template in self.templates, "Unknwon template %s" % template
            # Handle subject from template
            if not subject:
                assert self.templates[template].get('subject'), 'No subject defined in template %s' % template
                msg['Subject'] = self.templates[template]['subject'].format(**template_vars)

            # Put HTML part in last one to prefered it
            parts = []
            if self.templates[template].get('text'):
                if isinstance(self.templates[template]['text'], MakoTemplate):
                    parts.append((self.templates[template]['text'].render(**template_vars), 'plain'))
                else:
                    parts.append((self.templates[template]['text'].format(**template_vars), 'plain'))
            if self.templates[template].get('html'):
                if isinstance(self.templates[template]['html'], MakoTemplate):
                    parts.append((self.templates[template]['html'].render(**template_vars), 'html'))
                else:
                    parts.append((self.templates[template]['html'].format(**template_vars), 'html'))

            for body, mime_type in parts:
                msg.attach(MIMEText(body.encode(encoding), mime_type, _charset=encoding))
        else:
            assert subject, 'No subject provided'
            if text_body:
                msg.attach(MIMEText(text_body.encode(encoding), 'plain', _charset=encoding))
            if html_body:
                msg.attach(MIMEText(html_body.encode(encoding), 'html', _charset=encoding))
        if attachment_files:
            for filepath in attachment_files:
                with open(filepath, 'rb') as fp:
                    part = MIMEBase('application', "octet-stream")
                    part.set_payload(fp.read())
                    encode_base64(part)
                    part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(filepath))
                    msg.attach(part)
        if attachment_payloads:
            for filename, payload in attachment_payloads:
                part = MIMEBase('application', "octet-stream")
                part.set_payload(payload)
                encode_base64(part)
                part.add_header('Content-Disposition', 'attachment; filename="%s"' % filename)
                msg.attach(part)
        return msg

    def send(self, rcpt_to, msg=None, subject=None, just_try=False, **forge_args):
        """
        Send an email

        :param rcpt_to:     The recipient of the email. Could be a tuple(name, email)
                            or just the email of the recipient.
        :param msg:         The message of this email (as MIMEBase or derivated classes)
        :param subject:     The subject of the email (only if the message is not provided
                            using msg parameter)
        :param just_try:    Enable just try mode (do not really send email, default: as defined on initialization)

        All other parameters will be consider as parameters to forge the message
        (only if the message is not provided using msg parameter).
        """
        msg = msg if msg else self.forge_message(rcpt_to, subject, **forge_args)

        if just_try or self.just_try:
            log.debug('Just-try mode: do not really send this email to %s (subject="%s")', rcpt_to, subject or msg.get('subject', 'No subject'))
            return True

        if self.catch_all_addr:
            catch_addr = self.catch_all_addr
            log.debug('Catch email originaly send to %s to %s', rcpt_to, catch_addr)
            rcpt_to = catch_addr

        try:
            if self.smtp_ssl:
                logging.info("Establish SSL connection to server %s:%s", self.smtp_host, self.smtp_port)
                server = smtplib.SMTP_SSL(self.smtp_host, self.smtp_port)
            else:
                logging.info("Establish connection to server %s:%s", self.smtp_host, self.smtp_port)
                server = smtplib.SMTP(self.smtp_host, self.smtp_port)
                if self.smtp_tls:
                    logging.info('Start TLS on SMTP connection')
                    server.starttls()
        except smtplib.SMTPException:
            log.error('Error connecting to SMTP server %s:%s', self.smtp_host, self.smtp_port, exc_info=True)
            return False

        if self.smtp_debug:
            server.set_debuglevel(True)

        if self.smtp_user and self.smtp_password:
            try:
                log.info('Try to authenticate on SMTP connection as %s', self.smtp_user)
                server.login(self.smtp_user, self.smtp_password)
            except smtplib.SMTPException:
                log.error('Error authenticating on SMTP server %s:%s with user %s', self.smtp_host, self.smtp_port, self.smtp_user, exc_info=True)
                return False

        error = False
        try:
            log.info('Sending email to %s', rcpt_to)
            server.sendmail(self.sender_email, [rcpt_to[1] if isinstance(rcpt_to, tuple) else rcpt_to], msg.as_string())
        except smtplib.SMTPException:
            error = True
            log.error('Error sending email to %s', rcpt_to, exc_info=True)
        finally:
            server.quit()

        return not error


if __name__ == '__main__':
    # Run tests
    import datetime
    import sys

    import argparse

    # Options parser
    parser = argparse.ArgumentParser()

    parser.add_argument(
        '-v', '--verbose',
        action="store_true",
        dest="verbose",
        help="Enable verbose mode"
    )

    parser.add_argument(
        '-d', '--debug',
        action="store_true",
        dest="debug",
        help="Enable debug mode"
    )

    parser.add_argument(
        '-l', '--log-file',
        action="store",
        type=str,
        dest="logfile",
        help="Log file path"
    )

    parser.add_argument(
        '-j', '--just-try',
        action="store_true",
        dest="just_try",
        help="Enable just-try mode"
    )

    email_opts = parser.add_argument_group('Email options')

    email_opts.add_argument(
        '-H', '--smtp-host',
        action="store",
        type=str,
        dest="email_smtp_host",
        help="SMTP host"
    )

    email_opts.add_argument(
        '-P', '--smtp-port',
        action="store",
        type=int,
        dest="email_smtp_port",
        help="SMTP port"
    )

    email_opts.add_argument(
        '-S', '--smtp-ssl',
        action="store_true",
        dest="email_smtp_ssl",
        help="Use SSL"
    )

    email_opts.add_argument(
        '-T', '--smtp-tls',
        action="store_true",
        dest="email_smtp_tls",
        help="Use TLS"
    )

    email_opts.add_argument(
        '-u', '--smtp-user',
        action="store",
        type=str,
        dest="email_smtp_user",
        help="SMTP username"
    )

    email_opts.add_argument(
        '-p', '--smtp-password',
        action="store",
        type=str,
        dest="email_smtp_password",
        help="SMTP password"
    )

    email_opts.add_argument(
        '-D', '--smtp-debug',
        action="store_true",
        dest="email_smtp_debug",
        help="Debug SMTP connection"
    )

    email_opts.add_argument(
        '-e', '--email-encoding',
        action="store",
        type=str,
        dest="email_encoding",
        help="SMTP encoding"
    )

    email_opts.add_argument(
        '-f', '--sender-name',
        action="store",
        type=str,
        dest="email_sender_name",
        help="Sender name"
    )

    email_opts.add_argument(
        '-F', '--sender-email',
        action="store",
        type=str,
        dest="email_sender_email",
        help="Sender email"
    )

    email_opts.add_argument(
        '-C', '--catch-all',
        action="store",
        type=str,
        dest="email_catch_all",
        help="Catch all sent email: specify catch recipient email address"
    )

    test_opts = parser.add_argument_group('Test email options')

    test_opts.add_argument(
        '-t', '--to',
        action="store",
        type=str,
        dest="test_to",
        help="Test email recipient",
    )

    test_opts.add_argument(
        '-m', '--mako',
        action="store_true",
        dest="test_mako",
        help="Test mako templating",
    )

    options = parser.parse_args()

    if not options.test_to:
        parser.error('You must specify test email recipient using -t/--to parameter')
        sys.exit(1)

    # Initialize logs
    logformat = '%(asctime)s - Test EmailClient - %(levelname)s - %(message)s'
    if options.debug:
        loglevel = logging.DEBUG
    elif options.verbose:
        loglevel = logging.INFO
    else:
        loglevel = logging.WARNING

    if options.logfile:
        logging.basicConfig(filename=options.logfile, level=loglevel, format=logformat)
    else:
        logging.basicConfig(level=loglevel, format=logformat)

    if options.email_smtp_user and not options.email_smtp_password:
        import getpass
        options.email_smtp_password = getpass.getpass('Please enter SMTP password: ')

    logging.info('Initialize Email client')
    email_client = EmailClient(
        smtp_host=options.email_smtp_host,
        smtp_port=options.email_smtp_port,
        smtp_ssl=options.email_smtp_ssl,
        smtp_tls=options.email_smtp_tls,
        smtp_user=options.email_smtp_user,
        smtp_password=options.email_smtp_password,
        smtp_debug=options.email_smtp_debug,
        sender_name=options.email_sender_name,
        sender_email=options.email_sender_email,
        catch_all_addr=options.email_catch_all,
        just_try=options.just_try,
        encoding=options.email_encoding,
        templates=dict(
            test=dict(
                subject="Test email",
                text=(
                    "Just a test email sent at {sent_date}." if not options.test_mako else
                    MakoTemplate("Just a test email sent at ${sent_date}.")
                ),
                html=(
                    "<strong>Just a test email.</strong> <small>(sent at {sent_date})</small>" if not options.test_mako else
                    MakoTemplate("<strong>Just a test email.</strong> <small>(sent at ${sent_date})</small>")
                )
            )
        )
    )

    logging.info('Send a test email to %s', options.test_to)
    if email_client.send(options.test_to, template='test', sent_date=datetime.datetime.now()):
        logging.info('Test email sent')
        sys.exit(0)
    logging.error('Fail to send test email')
    sys.exit(1)