#! /usr/bin/env python

import getpass
import optparse
import os
import quopri
import shutil
import smtplib
import socket
import subprocess
import sys
import tempfile
import time
import email
import email.charset
import email.header
import email.message
import warnings

with warnings.catch_warnings():
    warnings.simplefilter("ignore")
    # Python 2.6 reports this as deprecated.
    import mimify

try:
    # Python 3
    from configparser import ConfigParser
    from configparser import NoSectionError
    from configparser import NoOptionError
except ImportError:
    # Python 2
    from ConfigParser import ConfigParser
    from ConfigParser import NoSectionError
    from ConfigParser import NoOptionError

VERSION   = "0.6-25"  # Filled in automatically.

Name      = "git-notifier"
CacheFile = ".%s.dat" % Name
Separator = "\n>---------------------------------------------------------------\n"
NoDiff    = "[nodiff]"
NoMail    = "[nomail]"
CfgName   = "git-notifier.conf"

try:
    # 2-tuple: (name, boolean) with boolen being True if file must exist.
    ConfigPath = (os.environ["GIT_NOTIFIER_CONFIG"], True)
except KeyError:
    ConfigPath = (os.path.join(os.path.dirname(os.path.realpath(__file__)), CfgName), False)

gitolite = "GL_USER" in os.environ

mimify.CHARSET = 'UTF-8'
email.charset.add_charset('utf-8', email.Charset.QP, email.Charset.QP, 'utf-8')

if "LOGNAME" in os.environ:
    whoami = os.environ["LOGNAME"]
else:
    whoami = getpass.getuser()

sender = os.environ["GL_USER"] if gitolite else None

Options = [
    # Name, argument, default, help,
    ("allchanges", True, set(), "branches for which *all* changes are to be reported"),
    ("debug", False, False, "enable debug output"),
    ("diff", True, None, "mail out diffs between two revisions"),
    ("emailprefix", True, "[git/%r]", "Subject prefix for mails"),
    ("hostname", True, socket.gethostname(), "host where the repository is hosted"),
    ("log", True, "%s.log" % Name, "set log output"),
    ("mailcmd", True, "/usr/sbin/sendmail -t", "path to mailer executable"),
    ("mailinglist", True, whoami, "destination address for mails"),
    ("manual", True, None, "notify for a manually given set of revisions"),
    ("maxdiffsize", True, 50, "limit the size of diffs in mails (KB)"),
    ("mailsubjectlen", True, None, "limit the length of mail subjects (number of chars)"),
    ("noupdate", False, False, "do not update the state file"),
    ("repouri", True, None, "full URI for the repository"),
    ("gitbasedir", True, os.path.dirname(os.getcwd()), "base directory for all git repositories"),
    ("sender", True, sender, "sender address for mails"),
    ("link", True, None, "Link to insert into mail, %s will be replaced with revision"),
    ("updateonly", False, False, "update state file only, no mails"),
    ("users", True, None, "location of a user-to-email mapping file"),
    ("replyto", True, None, "email address for reply-to header"),
    ("mergediffs", True, set(), "branches for which complete merge diffs are to be included"),
    ("ignoreremotes", False, False, "don't report commits that a remote already knows"),
    ("branches", True, None, "Branches to include or skip"),
    ("maxage", True, 30, "max age for commits to report, older ones will be ignored (days; default 30)"),
    ("mailserver", True, None, "SMTP server. If None, sendmail binary is used instead"),
    ("config", True, ConfigPath, "Path to configuration file"),
    ]

class State:
    def __init__(self):
        self.clear()

    def clear(self):
        self.heads = {}
        self.tags = {}
        self.revs = set()
        self.diffs = set()

        self.reported = set() # Revs reported this run so far.

    def writeTo(self, file):
        if os.path.exists(CacheFile):
            try:
                shutil.move(CacheFile, CacheFile + ".bak")
            except IOError:
                pass

        out = open(file, "w")

        for (head, ref) in self.heads.items():
            print >>out, "head", head, ref

        for (tag, ref) in self.tags.items():
            print >>out, "tag", tag, ref

        for rev in self.revs:
            print >>out, "rev", rev

        # No longer used.
        #
        # for rev in self.diffs:
        #     print >>out, "diff", rev

    def readFrom(self, file):
        self.clear()

        for line in open(file):

            line = line.strip()
            if not line or line.startswith("#"):
                continue

            m = line.split()

            if len(m) == 3:
                (type, key, val) = (m[0], m[1], m[2])
            else:
                # No heads.
                (type, key, val) = (m[0], m[1], "")

            if type == "head":
                self.heads[key] = val

            elif type == "tag":
                self.tags[key] = val

            elif type == "rev":
                self.revs.add(key)

            elif type == "diff":
                self.diffs.add(key)

            else:
                error("unknown type %s in cache file" % type)

class GitConfig:
    def __init__(self, args):
        self.parseArgs(args)
        self.maxdiffsize *= 1024 # KBytes to bytes.

        now = time.time()
        self.maxage *= (24 * 60 * 60) # Days to secs.
        self.maxage = int(now) - self.maxage

        if self.allchanges and not isinstance(self.allchanges, set):
            self.allchanges = set([head.strip() for head in self.allchanges.split(",")])

        if self.mergediffs and not isinstance(self.mergediffs, set):
            self.mergediffs = set([head.strip() for head in self.mergediffs.split(",")])

        if not self.debug:
            self.log = open(self.log, "a")
        else:
            self.log = sys.stderr

        if not self.users and "GL_ADMINDIR" in os.environ:
            users = os.path.join(os.environ["GL_ADMINDIR"], "conf/sender.cfg")
            if os.path.exists(users):
                self.users = users

        self.head_include = set()
        self.head_exclude = set()

        if self.branches:
            branches = [b.strip() for b in self.branches.split(",")]

            for b in branches:
                if b.startswith("-"):
                    self.head_exclude.add(b[1:])
                else:
                    self.head_include.add(b)

        self.readUsers()

    def parseArgs(self, args):
        parser = optparse.OptionParser(version=VERSION)
        config = ConfigParser()
        cfgpath = ConfigPath

        for i in range(len(args)):
            if args[i] == "--config":
                cfgpath = (args[i+1], True)
                break

        if os.path.exists(cfgpath[0]):
            try:
                config.read(cfgpath[0])
            except IOError as e:
                print >>sys.stderr, "error reading configuration file: %s" % e
                sys.exit(1)

        elif cfgpath[1]:
            print >>sys.stderr, "cannot open configuration file: %s" % cfgpath[0]
            sys.exit(1)

        for (name, arg, default, help) in Options:
            if config:
                default = self._get_from_config_parser(config, name, arg, default)

            defval = self._git_config(name, default)

            if isinstance(default, int):
                defval = int(defval)

            if not arg:
                defval = bool(defval)

            if not arg:
                action = "store_true" if not default else "store_false"
                parser.add_option("--%s" % name, action=action, dest=name, default=defval, help=help)

            else:
                type = "string" if not isinstance(default, int) else "int"
                parser.add_option("--%s" % name, action="store", type=type, default=defval, dest=name, help=help)

        (options, args) = parser.parse_args(args)

        if len(args) != 0:
            parser.error("incorrect number of arguments")

        for (name, arg, default, help) in Options:
            self.__dict__[name] = options.__dict__[name]

    def readUsers(self):
        if self.users and os.path.exists(self.users):
            for line in open(self.users):
                line = line.strip()
                if not line or line.startswith("#"):
                    continue

                m = line.split()

                if self.sender and self.sender == m[0]:
                    self.sender = " ".join(m[1:])
                    break

    def _git_config(self, key, default):
        cfg = git(["config hooks.%s" % key])
        return cfg[0] if cfg else default

    def _get_from_config_parser(self, config, key, arg, default):
        try:
            if arg:
                return config.get('git-notifier', key)
            else:
                return config.getboolean('git-notifier', key)
        except (NoSectionError, NoOptionError):
            return default

def log(msg):
    print >>Config.log, "%s - %s" % (time.asctime(), msg)

def error(msg):
    log("Error: %s" % msg)
    sys.exit(1)

def git(args, stdout_to=subprocess.PIPE, all=False):
    if isinstance(args, tuple) or isinstance(args, list):
        args = " ".join(args)

    try:
        if Config.debug:
            print >>sys.stderr, "> git " + args
    except NameError:
        # Config may not be defined yet.
        pass

    try:
        child = subprocess.Popen("git " + args, shell=True, stdin=None, stdout=stdout_to, stderr=subprocess.PIPE)
        (stdout, stderr) = child.communicate()
    except OSError, e:
        error("cannot start git: %s" % str(e))

    if child.returncode != 0 and stderr:
        msg = ": %s" % stderr if stderr else ""
        error("git child failed with exit code %d%s" % (child.returncode, msg))

    if stdout_to != subprocess.PIPE:
        return []

    if not all:
        return [line.strip() for line in stdout.split("\n") if line]
    else:
        return stdout.split("\n")

def getHeads(state):
    for (rev, head) in [head.split() for head in git("show-ref --heads")]:
        if head.startswith("refs/heads/"):
            head = head[11:]

        state.heads[head] = rev

def getTags(state):
    for (rev, tag) in [head.split() for head in git("show-ref --tags")]:
        # We are only interested in annotaged tags.
        type = git("cat-file -t %s" % rev)[0]

        if type == "tag":
            if tag.startswith("refs/tags/"):
                tag = tag[10:]

            state.tags[tag] = rev

def getReachableRefs(state):
    keys = ["'%s'" % k for k in state.heads.keys() + state.tags.keys()]

    if keys:
        for rev in git(["rev-list"] + keys):
            state.revs.add(rev)

def getCurrent():
    state = State()
    getHeads(state)
    getTags(state)
    getReachableRefs(state)

    return state

def getRepoName():
    # Ensure gitbasedir ends with a trailing directory separator.
    gitbasedir = os.path.join(Config.gitbasedir, '')

    cwd = os.getcwd()
    if cwd.startswith(gitbasedir):
        repoName = cwd[len(gitbasedir):]
    else:
        # Fall back on old behaviour.
        repoName = os.path.basename(cwd)

    return repoName[0:-4] if repoName.endswith(".git") else repoName

def reportHead(head):
    if Config.head_include:
        return head in Config.head_include and not head in Config.head_exclude

    else:
        return not head in Config.head_exclude

Tmps = []

def makeTmp():
    global Tmps

    (fd, fname) = tempfile.mkstemp(prefix="%s-" % Name, suffix=".tmp")
    Tmps += [fname]

    return (os.fdopen(fd, "w"), fname)

def deleteTmps():
    for tmp in Tmps:
        os.unlink(tmp)

def mailTag(key, value):
    return "%-11s: %s" % (key, value)

def encodeHeader(hdr):
    try:
        hdr.decode('ascii')
    except UnicodeDecodeError:
        return email.header.Header(hdr, 'utf8').encode()
    else:
        return hdr

def encodeAddressList(addrs):
    def encodeAddress(name, addr):
        if name:
            return name + ' <' + addr + '>'
        else:
            return addr

    parsedAddrList = [email.utils.parseaddr(addr) for addr in addrs.split(',')]
    parsedAddrList = [(encodeHeader(name), addr) for (name, addr) in parsedAddrList]
    return ', '.join([encodeAddress(name, addr) for (name, addr) in parsedAddrList])

def getRepo():
    repo = Config.repouri

    if not repo:
        if gitolite:
            # Gitolite version.
            repo = "ssh://%u@%h/%r"
        else:
            # Standard version.
            repo = "ssh://%h/%r"

    repo = repo.replace('%u', whoami)
    repo = repo.replace('%h', Config.hostname)
    repo = repo.replace('%r', getRepoName())

    return repo

def startMailBody():
    (out, fname) = makeTmp()
    print >>out, mailTag("Repository", getRepo())
    return (out, fname)

def generateMail(subject, body, rev=None):
    if Config.mailsubjectlen:
        try:
            maxlen = int(Config.mailsubjectlen)
            if len(subject) > maxlen:
                subject = subject[:maxlen] + " ..."
        except ValueError:
            pass

    repo = getRepo()

    sender = Config.sender

    emailprefix = Config.emailprefix
    emailprefix = emailprefix.replace("%r", getRepoName())

    if not sender:
        if rev:
            sender = "".join(git("show '--pretty=format:%%cn <%%ce>' -s %s^{commit}" % rev))
        else:
            sender = whoami

    msg = email.message.Message()
    msg['From'] = encodeAddressList(sender)
    msg['To'] = encodeAddressList(Config.mailinglist)
    msg['Subject'] = encodeHeader('%s %s' % (emailprefix, subject))

    if Config.replyto:
        msg['Reply-To'] = encodeHeader(Config.replyto)

    if rev:
        date = "".join(git("show '--pretty=format:%%cD' -s %s^{commit}" % rev))
        msg['Date'] = encodeHeader(date)

    msg['X-Git-Repository'] = encodeHeader(repo)
    msg['X-Mailer'] = encodeHeader('%s %s' % (Name, VERSION))
    msg.set_payload(body)
    msg.set_charset('utf-8')

    return msg.as_string()

def sendMail(subject, out, fname, rev=None):
    out.close()

    msg = generateMail(subject, open(fname).read(), rev)

    if Config.debug:
        print msg
        print ""

    elif Config.mailserver:
        smtp = smtplib.SMTP(Config.mailserver)
        smtp.sendmail(Config.mailinglist, [Config.mailinglist], msg)
        smtp.quit()

    else:
        stdin = subprocess.Popen(Config.mailcmd, shell=True, stdin=subprocess.PIPE).stdin
        print >>stdin, msg
        stdin.close()

    # Wait a bit in case we're going to send more mails. Otherwise, the mails
    # get sent back-to-back and are likely to end up with identical timestamps,
    # which may then make them appear to have arrived in the wrong order.
    if not Config.debug:
        time.sleep(2)

def entryAdded(key, value, rev):
    if not reportHead(value):
        return

    log("New %s %s" % (key, value))

    (out, fname) = startMailBody()

    print >>out, mailTag("New %s" % key, value)
    print >>out, mailTag("Referencing", rev)

    sendMail("%s '%s' created" % (key, value), out, fname, rev)

def entryDeleted(key, value):
    if not reportHead(value):
        return

    log("Deleted %s %s" % (key, value))

    (out, fname) = startMailBody()

    print >>out, mailTag("Deleted %s" % key, value)

    sendMail("%s '%s' deleted" % (key, value), out, fname)

# Sends a mail for a notification consistent of two parts: (1) the output of a
# show command, and (2) the output of a diff command.
def sendChangeMail(rev, subject, heads, show_cmd, diff_cmd, stat_cmd):

    if not heads:
        # On no branch, probably some old commit that still
        # gets referenced somehow. Skip.
        return

    for head in heads:
        if reportHead(head):
            break
    else:
        return

    # Filter out revisions that are too old.
    if Config.maxage:
        age = git("show -s --format=%%ct %s " % rev, all=False)
        age = int(age[0])

        if age < Config.maxage:
            log("Revision %s too old for reporting, skipped" % rev)
            return

    (out, fname) = startMailBody()

    multi = "es" if len(heads) > 1 else ""
    heads = ",".join(heads)

    print >>out, mailTag("On branch%s" % multi, heads)

    if Config.link:
        url = Config.link.replace("%s", rev)
        url = url.replace("%r", getRepoName())
        print >>out, mailTag("Link", url)

    footer = ""
    show = git(show_cmd)

    for line in show:
        if NoDiff in line:
            break

        if NoMail in line:
            return

    else:
        (tmp, tname) = makeTmp()
        diff = git(diff_cmd, stdout_to=tmp)
        tmp.close()

        size = os.path.getsize(tname)

        if size > Config.maxdiffsize:
            (tmp, tname) = makeTmp()
            diff = git(stat_cmd, stdout_to=tmp)
            tmp.close()
            footer = "\nDiff suppressed because of size. To see it, use:\n\n    git %s" % diff_cmd

    print >>out, Separator

    for line in git(show_cmd, all=True):
        if line == "---":
            print >>out, Separator
        else:
            print >>out, line

    print >>out, Separator

    if tname:
        for line in open(tname):
            print >>out, line,

    print >>out, footer

    if Config.debug:
        print >>out, "-- "
        print >>out, "debug: show_cmd = git %s" % show_cmd
        print >>out, "debug: diff_cmd = git %s" % diff_cmd
        print >>out, "debug: stat_cmd = git %s" % stat_cmd

    sendMail(subject, out, fname, rev)

# Sends notification for a specific revision.
def commit(current, rev, force=False, subject_head=None):
    if rev in current.reported and not force:
        # Already reported in this run of the script.
        log("Flagged revision %s for notification, but already reported this time" % rev)
        return

    if Config.ignoreremotes:
        branches = [line.split()[-1] for line in git("branch -a --contains=%s" % rev)]

        for b in branches:
            if b.startswith("remotes/"):
                log("Flagged revision %s for notification, but already known by remote" % rev)
                return

    log("New revision %s" % rev)
    current.reported.add(rev)

    heads = [head.split()[-1] for head in git("branch --contains=%s" % rev)]
    if not subject_head:
        subject_head = ",".join(heads)

    merge_diff = "--cc"

    for head in heads:
        if head in Config.allchanges or head in Config.mergediffs:
            merge_diff = "-m"

    subject = git("show '--pretty=format:%%s (%%h)' -s %s" % rev)

    subject = "%s: %s" % (subject_head, subject[0])

    show_cmd = "show -s --no-color --find-copies-harder --pretty=medium %s" % rev
    diff_cmd = "diff-tree --root --patch-with-stat --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (merge_diff, rev)
    stat_cmd = "diff-tree --root --stat --no-color --find-copies-harder --ignore-space-at-eol %s" % rev

    sendChangeMail(rev, subject, heads, show_cmd, diff_cmd, stat_cmd)

# Sends a diff between two revisions.
#
# Only used in manual mode now.
def diff(head, first, last):
    # We record a pseudo-revision to avoid sending the same diff twice.
    rev = "%s-%s" % (head, last)
    if current and not rev in current.diffs:
        log("New diff revision %s" % rev)
        current.diffs.add(rev)

    log("Diffing %s..%s" % (first, last))

    subject = git("show '--pretty=format:%%s (%%h)' -s %s" % last)
    subject = "%s diff: %s" % (head, subject[0])

    heads = [head]

    show_cmd = "show -s --no-color --find-copies-harder --pretty=medium %s" % last
    diff_cmd = "diff --patch-with-stat -m --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (first, last)
    stat_cmd = "diff --stat -m --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (first, last)

    sendChangeMail(last, subject, heads, show_cmd, diff_cmd, stat_cmd)

# Sends pair-wise diffs for a path of revisions. Also records all revision on
# the path as seen.
#
# Only used in manual mode now.
def diffPath(head, revs):
    last = None

    for rev in revs:
        if last:
            diff(head, last, rev)
        last = rev

# Sends a commit notifications for a set of revisions.
def reportPath(current, revs, force=False, subject_head=None):
    if not revs:
        return

    # Sort updates by time.
    revs = git("rev-list --no-walk --reverse --date-order %s" % " ".join(revs))

    for rev in revs:
        commit(current, rev, force=force, subject_head=subject_head)

# Sends a summary mail for a set of revisions.
def headMoved(head, path):
    if not reportHead(head):
        return

    log("Head moved: %s -> %s" % (head, path[-1]))

    subject = git("show '--pretty=format:%%s (%%h)' -s %s" % path[-1])

    (out, fname) = startMailBody()

    print >>out, "Branch '%s' now includes:" % head
    print >>out, ""

    for rev in path:
        print >>out, "    ", git("show -s --pretty=oneline --abbrev-commit %s" % rev)[0]

    sendMail("%s's head updated: %s" % (head, subject[0]), out, fname)

Config = GitConfig(sys.argv[1:])

log("Running for %s" % os.getcwd())

if Config.debug:
    for (name, arg, default, help) in Options:
        print >>sys.stderr, "[Option %s: %s]" % (name, Config.__dict__[name])

cache = State()

if os.path.exists(CacheFile):
    cache.readFrom(CacheFile)
    report = (not Config.updateonly)

else:
    log("Initial run, no reporting of changes")
    report = False

current = None

if Config.diff:
    # Manual diff mode. The argument must be of the form "[old-rev..]new-rev".
    path = [rev.strip() for rev in Config.diff.split("..")]
    if len(path) == 1:
        path = ("%s~2" % path[0], path[0]) # sic! ~2.
    else:
        path = ("%s~1" % path[0], path[1])

    revs = git(["rev-list", "--reverse --date-order", path[1], "^%s" % path[0]])

    diffPath("<manual-diff>", revs)

    sys.exit(0)

current = getCurrent()

if Config.manual:
    # Manual report mode. The argument must be of the form "[old-rev..]new-rev".
    path = [rev.strip() for rev in Config.manual.split("..")]
    if len(path) == 1:
        path = ("%s~1" % path[0], path[0])

    revs = git(["rev-list", "--reverse --date-order", path[1], "^%s" % path[0]])
    reportPath(current, revs, force=True)

    sys.exit(0)

if report:
    # Check for changes to the set of heads.
    old = set(cache.heads.keys())
    new = set(current.heads.keys())

    for head in (new - old):
        entryAdded("branch", head, current.heads[head])

    for head in (old - new):
        entryDeleted("branch", head)

    stable_heads = new & old
    Config.allchanges = Config.allchanges & stable_heads

    # Check tags.
    old = set(cache.tags.keys())
    new = set(current.tags.keys())

    for tag in (new - old):
        entryAdded("tag", tag, current.tags[tag])

    for tag in (old - new):
        entryDeleted("tag", tag)

    # Notify for unreported commits.
    old = set(cache.revs)
    new = set(current.revs)
    new_revs = (new - old)
    reportPath(current, new_revs)

    # Do reports for the heads we want to see everything for.
    for head in stable_heads:
        old_rev = cache.heads[head]
        new_rev = current.heads[head]
        path = git(["rev-list", "--reverse --date-order", new_rev, "^%s" % old_rev])

        if head in Config.allchanges:
            # Want to see all commits for this head, even if already reported
            # in the past for some other. So we record these separately.
            reportPath(current, path, subject_head=head)
        else:
            # Just send a summary for heads that now include some new stuff.
            if len(set(path) - new_revs):
                headMoved(head, path)

if not Config.noupdate:
    current.writeTo(CacheFile)

deleteTmps()
