#!/usr/bin/env python3
# pylint: disable=C0103,W0603,W0621,E1101

"""
Meh mail client
A dumb Python scripts that leverages notmuch, mbsync, and msmtp
to become a fully-functional extremly-opinonated mail client.
"""

# TODO Features
#     TODO Implement initial command set
#     TODO Lockfiles for write operations on mail files (mbsync,
#     tags→maildir operations)
#     TODO OPTI Lockfile per account and process everything in parallel
#     (if implemented, this should be optional since while it may speed up
#     the mail fetching process, its multi-threading nature would cause a
#     lot of cache flushes and be not very efficient on battery)
#     TODO Handle true character width
#     TODO IMAP IDLE watches?
#     TODO GPG
# TODO (only then) Refactor
#     TODO OOP-based
#     TODO Merge file with melConf
#     TODO Un-ignore pyling warnings

import argparse
import configparser
import datetime
import email.message
import email.parser
import html
import logging
import os
import re
import shutil
import subprocess
import sys
import time
import typing

import colorama
import coloredlogs
import notmuch
import progressbar
import xdg.BaseDirectory

PERF_LAST = time.perf_counter()
PERF_DICT: typing.Dict[str, float] = dict()

a: typing.Any = 'DEBUG VARIABLE (empty)'


def perfstep(name: str) -> None:
    """
    DEBUG
    Small performance profiler to measure steps.
    Call with the name of the step when you just finished it.
    """
    current_time = time.perf_counter()
    global PERF_LAST
    global PERF_DICT
    diff = current_time - PERF_LAST
    if name not in PERF_DICT:
        PERF_DICT[name] = 0.0
    PERF_DICT[name] += diff
    PERF_LAST = time.perf_counter()


ACCOUNTS: typing.Dict[str, configparser.SectionProxy] = dict()
ALIASES: typing.Set[str] = set()  # All the emails the user is represented as
# TODO If the user send emails to himself, maybe that wont cut it.
DB = None
CONFIG = None


def notmuch_new() -> None:
    """
    Runs `notmuch new`, which basically update the database
    to match the mail folder.
    """
    close_database()
    log.info("Indexing mails")
    notmuchConfigPath = os.path.expanduser(
        "~/.config/notmuch-config")  # TODO Better
    cmd = ["notmuch", "--config", notmuchConfigPath, "new"]
    log.debug(" ".join(cmd))
    subprocess.run(cmd, check=True)


def list_folders() -> typing.List[typing.Tuple[str, ...]]:
    """
    List all the folders of the mail dir.
    """
    assert CONFIG
    storagePath = os.path.realpath(
        os.path.expanduser(CONFIG["GENERAL"]["storage"]))
    folders = list()
    for account in ACCOUNTS:
        storagePathAccount = os.path.join(storagePath, account)
        for root, dirs, _ in os.walk(storagePathAccount):
            if "cur" not in dirs or "new" not in dirs or "tmp" not in dirs:
                continue
            assert root.startswith(storagePath)
            path = root[len(storagePath):]
            pathSplit = path.split('/')
            if pathSplit[0] == '':
                pathSplit = pathSplit[1:]
            folders.append(tuple(pathSplit))
    return folders


def open_database(write: bool = False) -> None:
    """
    Open an access notmuch database in read or read+write mode.
    It is stored in the global DB.
    Be sure to require only in the mode you want to avoid deadlocks.
    """
    assert CONFIG
    global DB
    mode = notmuch.Database.MODE.READ_WRITE if write \
        else notmuch.Database.MODE.READ_ONLY
    if DB:
        if DB.mode == mode:
            return
        log.info("Current database not in mode %s, closing", mode)
        close_database()
    log.info("Opening database in mode %s", mode)
    dbPath = os.path.realpath(os.path.expanduser(CONFIG["GENERAL"]["storage"]))
    DB = notmuch.Database(mode=mode, path=dbPath)


def close_database() -> None:
    """
    Close the access notmuch database in read or read+write mode.
    It is stored in the global DB.
    """
    global DB
    if DB:
        log.info("Closing database")
        DB.close()
        DB = None


def generate_aliases() -> None:
    assert CONFIG
    for name in CONFIG.sections():
        if not name.islower():
            continue
        section = CONFIG[name]
        ALIASES.add(section["from"])
        if "alternatives" in section:
            for alt in section["alternatives"].split(";"):
                ALIASES.add(alt)
        ACCOUNTS[name] = section


MailLocation = typing.NewType('MailLocation', typing.Tuple[str, str, str])


def get_location(msg: notmuch.Message) -> MailLocation:
    """
    Return the filesystem location (relative to the mail directory)
    of the given message.
    """
    path = msg.get_filename()
    path = os.path.dirname(path)
    assert DB
    base = DB.get_path()
    assert path.startswith(base)
    path = path[len(base):]
    pathSplit = path.split('/')
    mailbox = pathSplit[1]
    assert mailbox in ACCOUNTS
    state = pathSplit[-1]
    folder = tuple(pathSplit[2:-1])
    assert state in {'cur', 'tmp', 'new'}
    return (mailbox, folder, state)


MAILBOX_COLORS: typing.Dict[str, str] = dict()


def get_mailbox_color(mailbox: str) -> str:
    """
    Return the color of the given mailbox in a ready to print
    string with ASCII escape codes.
    """
    # TODO Do not use 256³ colors but 16 colors
    assert CONFIG
    if mailbox not in MAILBOX_COLORS:
        colorStr = CONFIG[mailbox]["color"]
        colorStr = colorStr[1:] if colorStr[0] == '#' else colorStr
        R = int(colorStr[0:2], 16)
        G = int(colorStr[2:4], 16)
        B = int(colorStr[4:6], 16)
        MAILBOX_COLORS[mailbox] = '\x1b[38;2;{};{};{}m'.format(R, G, B)
    return MAILBOX_COLORS[mailbox]


def format_date(date: datetime.datetime) -> str:
    """
    Format the given date as a 9-characters width string.
    Show the time if the mail is less than 24h old,
    else show the date.
    """
    # TODO Do as the description say
    now = datetime.datetime.now()
    midnight = datetime.datetime(year=now.year, month=now.month, day=now.day)
    if date > midnight:
        return date.strftime('%H:%M:%S')
    # TODO Use my favourite date system
    return date.strftime('%d/%m/%y')


WIDTH_FIXED = 31
WIDTH_RATIO_DEST_SUBJECT = 0.3
ISATTY = sys.stdout.isatty()
DEST_WIDTH: typing.Optional[int] = None
SUBJECT_WIDTH: typing.Optional[int] = None


def compute_line_format() -> None:
    """
    Based on the terminal width, assign the width of flexible columns.
    """
    if ISATTY:
        columns, _ = shutil.get_terminal_size((80, 20))
        remain = columns - WIDTH_FIXED - 1
        global DEST_WIDTH, SUBJECT_WIDTH
        DEST_WIDTH = int(remain * WIDTH_RATIO_DEST_SUBJECT)
        SUBJECT_WIDTH = remain - DEST_WIDTH
    else:
        DEST_WIDTH = None
        SUBJECT_WIDTH = None


def clip_text(size: int, text: str) -> str:
    """
    Fit text into the given character size,
    fill with spaces if shorter,
    clip with … if larger.
    """
    if size is None:
        return text
    length = len(text)
    if length == size:
        return text
    if length > size:
        return text[:size-1] + '…'
    return text + ' ' * (size - length)


def isUID(uid: typing.Any) -> bool:
    """
    Tells if the provided string is a valid UID.
    """
    return isinstance(uid, str) and len(uid) == 12 \
        and bool(re.match('^[a-zA-Z0-9+/]{12}$', uid))


def print_msg(msg: notmuch.Message) -> None:
    """
    Print the given message header on one line.
    """
    if not DEST_WIDTH:
        compute_line_format()
    assert DEST_WIDTH and SUBJECT_WIDTH

    sep = " " if ISATTY else "\t"
    line = ""
    tags = set(msg.get_tags())
    mailbox, _, _ = get_location(msg)
    if ISATTY:
        line += get_mailbox_color(mailbox)

    # UID
    uid = None
    for tag in tags:
        if tag.startswith('tuid'):
            uid = tag[4:]
    assert uid and isUID(uid), "{uid} ({type(UID)}) is not a valid UID."
    line += uid

    # Date
    line += sep
    date = datetime.datetime.fromtimestamp(msg.get_date())
    line += format_date(date)

    # Icons
    line += sep

    def tags2col1(tag1: str, tag2: str,
                  characters: typing.Tuple[str, str, str, str]) -> None:
        """
        Show the presence/absence of two tags with one character.
        """
        nonlocal line
        both, first, second, none = characters
        if tag1 in tags:
            if tag2 in tags:
                line += both
            else:
                line += first
        else:
            if tag2 in tags:
                line += second
            else:
                line += none

    tags2col1('spam', 'draft', ('?', 'S', 'D', ' '))
    tags2col1('attachment', 'encrypted', ('E', 'A', 'E', ' '))
    tags2col1('unread', 'flagged', ('!', 'U', 'F', ' '))
    tags2col1('sent', 'replied', ('?', '↑', '↪', ' '))

    if 'sent' in tags:
        dest = msg.get_header("to")
    else:
        dest = msg.get_header("from")
    line += sep
    line += clip_text(DEST_WIDTH, dest)

    # Subject
    line += sep
    subject = msg.get_header("subject")
    line += clip_text(SUBJECT_WIDTH, subject)

    if ISATTY:
        line += colorama.Style.RESET_ALL
    print(line)


def extract_email(field: str) -> str:
    """
    Extract the email adress from a To: or From: field
    (usually the whole field or between < >)
    """
    try:
        sta = field.index('<')
        sto = field.index('>')
        return field[sta+1:sto]
    except ValueError:
        return field


def retag_msg(msg: notmuch.Message) -> None:
    """
    Update automatic tags for message.
    """
    _, folder, _ = get_location(msg)

    # Search-friendly folder name
    slugFolderList = list()
    for f, fold in [(f, folder[f]) for f in range(len(folder))]:
        if f == 0 and len(folder) > 1 and fold == "INBOX":
            continue
        slugFolderList.append(fold.upper())
    slugFolder = tuple(slugFolderList)

    tags = set(msg.get_tags())

    def tag_if(tag: str, condition: bool) -> None:
        """
        Ensure the presence/absence of tag depending on the condition.
        """
        nonlocal msg
        if condition and tag not in tags:
            msg.add_tag(tag)
        elif not condition and tag in tags:
            msg.remove_tag(tag)
    expeditor = extract_email(msg.get_header('from'))

    tag_if('inbox', slugFolder[0] == 'INBOX')
    tag_if('spam', slugFolder[0] in ('JUNK', 'SPAM'))
    tag_if('deleted', slugFolder[0] == 'TRASH')
    tag_if('draft', slugFolder[0] == 'DRAFTS')
    tag_if('sent', expeditor in ALIASES)
    tag_if('unprocessed', False)

    # UID
    uid = msg.get_header("X-TUID")
    if not isUID(uid):
        # TODO Happens to sent mails but should it?
        print(f"{msg.get_filename()} has no UID!")
        return
    uidtag = 'tuid{}'.format(uid)
    # Remove eventual others UID
    for tag in tags:
        if tag.startswith('tuid') and tag != uidtag:
            msg.remove_tag(tag)
    msg.add_tag(uidtag)


def applyMsgs(queryStr: str, action: typing.Callable, *args: typing.Any,
              showProgress: bool = False, write: bool = False,
              closeDb: bool = True, **kwargs: typing.Any) -> int:
    """
    Run a function on the messages selected by the given query.
    """
    open_database(write=write)

    log.info("Querying %s", queryStr)
    query = notmuch.Query(DB, queryStr)
    query.set_sort(notmuch.Query.SORT.OLDEST_FIRST)

    elements = query.search_messages()
    nbMsgs = query.count_messages()

    iterator = progressbar.progressbar(
        elements, max_value=nbMsgs) if showProgress else elements

    log.info("Executing %s", action)
    for msg in iterator:
        if write:
            msg.freeze()

        action(msg, *args, **kwargs)

        if write:
            msg.thaw()
            msg.tags_to_maildir_flags()

    if closeDb:
        close_database()

    return nbMsgs


def notify_msg(msg: notmuch.Message) -> None:
    """
    Send a notification for the given message.
    """
    log.info("Sending notification for %s", msg)
    subject = msg.get_header("subject")
    expd = msg.get_header("from")
    account, _, _ = get_location(msg)

    summary = '{} (<i>{}</i>)'.format(html.escape(expd), account)
    body = html.escape(subject)
    cmd = ["notify-send", "-u", "low", "-i", "mail-message-new", summary, body]
    print(' '.join(cmd))
    subprocess.run(cmd, check=False)


def notify_all() -> None:
    """
    Send a notification for unprocessed and unread message.
    Basically should only send a notification for a given message once
    since it should be marked as processed right after.
    """
    open_database()
    nbMsgs = applyMsgs('tag:unread and tag:unprocessed', notify_msg)
    if nbMsgs > 0:
        log.info("Playing notification sound (%d new message(s))", nbMsgs)
        cmd = ["play", "-n", "synth", "sine", "E4", "sine", "A5",
               "remix", "1-2", "fade", "0.5", "1.2", "0.5", "2"]
        subprocess.run(cmd, check=False)
    close_database()


def chunks(l: str, n: int) -> typing.Iterable[str]:
    """Yield successive n-sized chunks from l."""
    # From https://stackoverflow.com/a/312464
    for i in range(0, len(l), n):
        yield l[i:i + n]


def apply_msgs_input(argmessages: typing.List[str], action: typing.Callable,
                     write: bool = False) -> None:
    """
    Run a function on the message given by the user.
    """
    if not argmessages:
        fromStdin = not sys.stdin.isatty()
    if argmessages:
        fromStdin = len(argmessages) == 1 and argmessages == '-'

    messages = list()
    if fromStdin:
        for line in sys.stdin:
            uid = line[:12]
            if not isUID(uid):
                log.error("Not an UID: %s", uid)
                continue
            messages.append(uid)
    else:
        for uids in argmessages:
            if len(uids) > 12:
                log.warning("Might have forgotten some spaces between the " +
                            "UIDs. Don't worry, I'll split them for you")
            for uid in chunks(uids, 12):
                if not isUID(uid):
                    log.error("Not an UID: %s", uid)
                    continue
                messages.append(uid)

    for message in messages:
        queryStr = f'tag:tuid{message}'
        nbMsgs = applyMsgs(queryStr, action, write=write, closeDb=False)
        if nbMsgs < 1:
            log.error("Couldn't execute function for message %s", message)
    close_database()


def format_header_value(val: str) -> str:
    """
    Return split header values in a contiguous string.
    """
    return val.replace('\n', '').replace('\t', '').strip()


def sizeof_fmt(num: int, suffix: str = 'B') -> str:
    """
    Print the given size in a human-readable format.
    """
    remainder = float(num)
    # From https://stackoverflow.com/a/1094933
    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
        if abs(remainder) < 1024.0:
            return "%3.1f %s%s" % (remainder, unit, suffix)
        remainder /= 1024.0
    return "%.1f %s%s" % (remainder, 'Yi', suffix)


PART_MULTI_FORMAT = colorama.Fore.BLUE + \
    '{nb} {indent}+ {typ}' + colorama.Style.RESET_ALL
PART_LEAF_FORMAT = colorama.Fore.BLUE + \
    '{nb} {indent}→ {desc} ({typ}; {size})' + \
    colorama.Style.RESET_ALL


def show_parts_tree(part: email.message.Message,
                    depth: int = 0, nb: int = 1) -> int:
    """
    Show a tree of the parts contained in a message.
    Return the number of parts of the mesage.
    """
    indent = depth * '\t'
    typ = part.get_content_type()

    if part.is_multipart():
        print(PART_MULTI_FORMAT.format(nb=nb, indent=indent, typ=typ))
        payl = part.get_payload()
        assert isinstance(payl, list)
        size = 1
        for obj in payl:
            size += show_parts_tree(obj, depth=depth+1, nb=nb+size)
        return size

    # size = len(part.get_payload(decode=True))
    payl = part.get_payload(decode=True)
    assert isinstance(payl, bytes)
    size = len(payl)
    desc = part.get('Content-Description', '<no description>')
    print(PART_LEAF_FORMAT.format(nb=nb, indent=indent, typ=typ,
                                  desc=desc, size=sizeof_fmt(size)))
    return 1


INTERESTING_HEADERS = ["Date", "From", "Subject", "To", "Cc", "Message-Id"]
HEADER_FORMAT = colorama.Fore.BLUE + colorama.Style.BRIGHT + \
    '{}:' + colorama.Style.NORMAL + ' {}' + colorama.Style.RESET_ALL


def read_msg(msg: notmuch.Message) -> None:
    # Parse
    filename = msg.get_filename()
    parser = email.parser.BytesParser()
    with open(filename, 'rb') as f:
        mail = parser.parse(f)

    # Debug
    global a
    a = mail

    # Defects
    if mail.defects:
        log.warning("Defects found in the mail:")
        for defect in mail.defects:
            log.warning(defect)

    # Headers
    for key in INTERESTING_HEADERS:
        val = mail.get(key)
        if val:
            assert isinstance(val, str)
            val = format_header_value(val)
            print(HEADER_FORMAT.format(key, val))
    # TODO Show all headers
    # TODO BONUS Highlight failed verifications

    show_parts_tree(mail)
    print()

    # Show text/plain
    for part in mail.walk():
        if part.get_content_type() == "text/plain":
            payl = part.get_payload(decode=True)
            assert isinstance(payl, bytes)
            print(payl.decode())


perfstep("definitions")

if __name__ == "__main__":
    # Main arguments
    parser = argparse.ArgumentParser(description="Meh mail client")
    selectedVerbosityLevels = ["DEBUG", "INFO", "WARNING", "ERROR", "FATAL"]
    parser.add_argument('-v', '--verbosity', choices=selectedVerbosityLevels,
                        default='WARNING', help="Verbosity of log messages")
    # parser.add_argument('-n', '--dry-run', action='store_true',
    #                     help="Don't do anything")  # DEBUG
    defaultConfigFile = os.path.join(
        xdg.BaseDirectory.xdg_config_home, 'mel', 'accounts.conf')
    parser.add_argument('-c', '--config', default=defaultConfigFile,
                        help="Accounts config file")

    subparsers = parser.add_subparsers(help="Action to execute")

    # List messages

    def func_default(_: argparse.Namespace) -> None:
        """
        Default operation: list all message in the inbox
        """
        applyMsgs('tag:inbox', print_msg)
    parser.set_defaults(func=func_default)

    # inbox (default)
    def func_inbox(args: argparse.Namespace) -> None:
        """
        Inbox operation: list all message in the inbox,
        possibly only the unread ones.
        """
        queryStr = 'tag:unread' if args.only_unread else 'tag:inbox'
        applyMsgs(queryStr, print_msg)

    parserInbox = subparsers.add_parser(
        "inbox", help="Show unread, unsorted and flagged messages")
    parserInbox.add_argument('-u', '--only-unread', action='store_true',
                             help="Show unread messages only")
    # TODO Make this more relevant
    parserInbox.set_defaults(func=func_inbox)

    # list folder [--recurse]
    # List actions

    # flag msg...

    def func_flag(args: argparse.Namespace) -> None:
        """
        Flag operation: Flag user selected messages.
        """
        def flag_msg(msg: notmuch.Message) -> None:
            """
            Flag given message.
            """
            msg.add_tag('flagged')
        apply_msgs_input(args.message, flag_msg, write=True)
    parserFlag = subparsers.add_parser("flag", help="Mark messages as flagged")
    parserFlag.add_argument('message', nargs='*', help="Messages")
    parserFlag.set_defaults(func=func_flag)

    # unflag msg...

    def func_unflag(args: argparse.Namespace) -> None:
        """
        Unflag operation: Flag user selected messages.
        """
        def unflag_msg(msg: notmuch.Message) -> None:
            """
            Unflag given message.
            """
            msg.remove_tag('flagged')
        apply_msgs_input(args.message, unflag_msg, write=True)
    parserUnflag = subparsers.add_parser(
        "unflag", help="Mark messages as not-flagged")
    parserUnflag.add_argument('message', nargs='*', help="Messages")
    parserUnflag.set_defaults(func=func_unflag)

    # delete msg...
    # spam msg...
    # move dest msg...
    # Read message

    # read msg [--html] [--plain] [--browser]

    def func_read(args: argparse.Namespace) -> None:
        """
        Read operation: show full content of selected message
        """
        apply_msgs_input(args.message, read_msg)
    parserRead = subparsers.add_parser("read", help="Read message")
    parserRead.add_argument('message', nargs=1, help="Messages")
    parserRead.set_defaults(func=func_read)

    # attach msg [id] [--save] (list if no id, xdg-open else)
    # Redaction
    # new account
    # reply msg [--all]
    # Folder management
    # tree [folder]
    # mkdir folder
    # rmdir folder (prevent if folder isn't empty (mail/subfolder))
    # (yeah that should do)
    # Meta
    # setup (interactive thing maybe)

    # fetch (mbsync, notmuch new, retag, notify; called by greater gods)

    def func_fetch(args: argparse.Namespace) -> None:
        """
        Fetch operation: Sync remote databases with the local one.
        """
        # Fetch mails
        log.info("Fetching mails")
        mbsyncConfigPath = os.path.expanduser(
            "~/.config/mbsyncrc")  # TODO Better
        cmd = ["mbsync", "--config", mbsyncConfigPath, "--all"]
        subprocess.run(cmd, check=True)

        # Index new mails
        notmuch_new()

        # Notify
        notify_all()

        # Tag new mails
        applyMsgs('tag:unprocessed', retag_msg, showProgress=True, write=True)

    parserFetch = subparsers.add_parser(
        "fetch", help="Fetch mail, tag them, and run notifications")
    parserFetch.set_defaults(func=func_fetch)

    # Debug
    # debug (various)

    def func_expose(_: argparse.Namespace) -> None:
        """
        DEBUG
        """
        # And leave the door open
        def expose_object(msg: typing.Any) -> None:
            """
            DEBUG
            """
            global a
            a = msg
        applyMsgs('tag:tuidyviU45m6flff', expose_object, closeDb=False)

    def func_debug(_: argparse.Namespace) -> None:
        """
        DEBUG
        """
        from pprint import pprint
        pprint(list_folders())
    parserDebug = subparsers.add_parser(
        "debug", help="Who know what this holds...")
    parserDebug.set_defaults(verbosity='DEBUG')
    parserDebug.set_defaults(func=func_debug)

    # retag (all or unprocessed)
    def func_retag(_: argparse.Namespace) -> None:
        """
        Retag operation: Manually retag all the mails in the database.
        Mostly debug I suppose.
        """
        applyMsgs('*', retag_msg, showProgress=True, write=True)
    parserRetag = subparsers.add_parser(
        "retag", help="Retag all mails (when you changed configuration)")
    parserRetag.set_defaults(func=func_retag)

    # all
    def func_all(_: argparse.Namespace) -> None:
        """
        All operation: list every single message.
        """
        applyMsgs('*', print_msg)

    parserAll = subparsers.add_parser("all", help="Show ALL messages")
    parserAll.set_defaults(func=func_all)

    # Init
    args = parser.parse_args()
    perfstep("parse_args")

    colorama.init()
    coloredlogs.install(level=args.verbosity, fmt='%(levelname)s %(message)s')
    log = logging.getLogger()

    log.info("Loading config %s", args.config)
    if not os.path.isfile(args.config):
        log.fatal("config file not found: %s", args.config)
        sys.exit(1)
        # TODO Create it, maybe?
    CONFIG = configparser.ConfigParser()
    CONFIG.read(args.config)

    generate_aliases()
    perfstep("config")

    if args.func:
        log.info("Executing function %s", args.func)
        args.func(args)

    perfstep("exec")

    # DEBUG
    for kv in sorted(PERF_DICT.items(), key=lambda p: p[1]):
        log.debug("{1:.6f}s {0}".format(*kv))
    sys.exit(0)