import contextlib
import hashlib

from mercurial.node import hex, bin, nullid
from mercurial import (
    branchmap,
    changegroup,
    cmdutil,
    encoding,
    error,
    extensions,
    scmutil,
)

def _filename(repo):
    """name of a branchcache file for a given repo or repoview"""
    filename = "cache/topicmap"
    if repo.filtername:
        filename = '%s-%s' % (filename, repo.filtername)
    return filename

oldbranchcache = branchmap.branchcache

def _phaseshash(repo, maxrev):
    revs = set()
    cl = repo.changelog
    fr = cl.filteredrevs
    nm = cl.nodemap
    for roots in repo._phasecache.phaseroots[1:]:
        for n in roots:
            r = nm.get(n)
            if r not in fr and r < maxrev:
                revs.add(r)
    key = nullid
    revs = sorted(revs)
    if revs:
        s = hashlib.sha1()
        for rev in revs:
            s.update('%s;' % rev)
        key = s.digest()
    return key

@contextlib.contextmanager
def usetopicmap(repo):
    """use awful monkey patching to ensure topic map usage

    During the extend of the context block, The topicmap should be used and
    updated instead of the branchmap."""
    oldbranchcache = branchmap.branchcache
    oldfilename = branchmap._filename
    oldread = branchmap.read
    oldcaches = getattr(repo, '_branchcaches', {})
    try:
        branchmap.branchcache = topiccache
        branchmap._filename = _filename
        branchmap.read = readtopicmap
        repo._branchcaches = getattr(repo, '_topiccaches', {})
        yield
        repo._topiccaches = repo._branchcaches
    finally:
        repo._branchcaches = oldcaches
        branchmap.branchcache = oldbranchcache
        branchmap._filename = oldfilename
        branchmap.read = oldread

def cgapply(orig, repo, *args, **kwargs):
    """make sure a topicmap is used when applying a changegroup"""
    with usetopicmap(repo):
        return orig(repo, *args, **kwargs)

def commitstatus(orig, repo, node, branch, bheads=None, opts=None):
    # wrap commit status use the topic branch heads
    ctx = repo[node]
    if ctx.topic() and ctx.branch() == branch:
        bheads = repo.branchheads("%s:%s" % (branch, ctx.topic()))
    return orig(repo, node, branch, bheads=bheads, opts=opts)

class topiccache(oldbranchcache):

    def __init__(self, *args, **kwargs):
        otherbranchcache = branchmap.branchcache
        try:
            # super() call may fail otherwise
            branchmap.branchcache = oldbranchcache
            super(topiccache, self).__init__(*args, **kwargs)
            if self.filteredhash is None:
                self.filteredhash = nullid
            self.phaseshash = nullid
        finally:
            branchmap.branchcache = otherbranchcache

    def copy(self):
        """return an deep copy of the branchcache object"""
        new = topiccache(self, self.tipnode, self.tiprev, self.filteredhash,
                         self._closednodes)
        if self.filteredhash is None:
            self.filteredhash = nullid
        new.phaseshash = self.phaseshash
        return new

    def branchtip(self, branch, topic=''):
        '''Return the tipmost open head on branch head, otherwise return the
        tipmost closed head on branch.
        Raise KeyError for unknown branch.'''
        if topic:
            branch = '%s:%s' % (branch, topic)
        return super(topiccache, self).branchtip(branch)

    def branchheads(self, branch, closed=False, topic=''):
        if topic:
            branch = '%s:%s' % (branch, topic)
        return super(topiccache, self).branchheads(branch, closed=closed)

    def validfor(self, repo):
        """Is the cache content valid regarding a repo

        - False when cached tipnode is unknown or if we detect a strip.
        - True when cache is up to date or a subset of current repo."""
        # This is copy paste of mercurial.branchmap.branchcache.validfor in
        # 69077c65919d With a small changes to the cache key handling to
        # include phase information that impact the topic cache.
        #
        # All code changes should be flagged on site.
        try:
            if (self.tipnode == repo.changelog.node(self.tiprev)):
                fh = scmutil.filteredhash(repo, self.tiprev)
                if fh is None:
                    fh = nullid
                if ((self.filteredhash == fh)
                     and (self.phaseshash == _phaseshash(repo, self.tiprev))):
                    return True
            return False
        except IndexError:
            return False

    def write(self, repo):
        # This is copy paste of mercurial.branchmap.branchcache.write in
        # 69077c65919d With a small changes to the cache key handling to
        # include phase information that impact the topic cache.
        #
        # All code changes should be flagged on site.
        try:
            f = repo.vfs(_filename(repo), "w", atomictemp=True)
            cachekey = [hex(self.tipnode), str(self.tiprev)]
            # [CHANGE] we need a hash in all cases
            assert self.filteredhash is not None
            cachekey.append(hex(self.filteredhash))
            cachekey.append(hex(self.phaseshash))
            f.write(" ".join(cachekey) + '\n')
            nodecount = 0
            for label, nodes in sorted(self.iteritems()):
                for node in nodes:
                    nodecount += 1
                    if node in self._closednodes:
                        state = 'c'
                    else:
                        state = 'o'
                    f.write("%s %s %s\n" % (hex(node), state,
                                            encoding.fromlocal(label)))
            f.close()
            repo.ui.log('branchcache',
                        'wrote %s branch cache with %d labels and %d nodes\n',
                        repo.filtername, len(self), nodecount)
        except (IOError, OSError, error.Abort) as inst:
            repo.ui.debug("couldn't write branch cache: %s\n" % inst)
            # Abort may be raise by read only opener
            pass

    def update(self, repo, revgen):
        """Given a branchhead cache, self, that may have extra nodes or be
        missing heads, and a generator of nodes that are strictly a superset of
        heads missing, this function updates self to be correct.
        """
        oldgetbranchinfo = repo.revbranchcache().branchinfo
        try:
            def branchinfo(r):
                info = oldgetbranchinfo(r)
                topic = ''
                ctx = repo[r]
                if ctx.mutable():
                    topic = ctx.topic()
                branch = info[0]
                if topic:
                    branch = '%s:%s' % (branch, topic)
                return (branch, info[1])
            repo.revbranchcache().branchinfo = branchinfo
            super(topiccache, self).update(repo, revgen)
            if self.filteredhash is None:
                self.filteredhash = nullid
            self.phaseshash = _phaseshash(repo, self.tiprev)
        finally:
            repo.revbranchcache().branchinfo = oldgetbranchinfo

def readtopicmap(repo):
    # This is copy paste of mercurial.branchmap.read in 69077c65919d
    # With a small changes to the cache key handling to include phase
    # information that impact the topic cache.
    #
    # All code changes should be flagged on site.
    try:
        f = repo.vfs(_filename(repo))
        lines = f.read().split('\n')
        f.close()
    except (IOError, OSError):
        return None

    try:
        cachekey = lines.pop(0).split(" ", 2)
        last, lrev = cachekey[:2]
        last, lrev = bin(last), int(lrev)
        filteredhash = bin(cachekey[2]) # [CHANGE] unconditional filteredhash
        partial = topiccache(tipnode=last, tiprev=lrev,
                             filteredhash=filteredhash)
        partial.phaseshash = bin(cachekey[3]) # [CHANGE] read phaseshash
        if not partial.validfor(repo):
            # invalidate the cache
            raise ValueError('tip differs')
        cl = repo.changelog
        for l in lines:
            if not l:
                continue
            node, state, label = l.split(" ", 2)
            if state not in 'oc':
                raise ValueError('invalid branch state')
            label = encoding.tolocal(label.strip())
            node = bin(node)
            if not cl.hasnode(node):
                raise ValueError('node %s does not exist' % hex(node))
            partial.setdefault(label, []).append(node)
            if state == 'c':
                partial._closednodes.add(node)
    except KeyboardInterrupt:
        raise
    except Exception as inst:
        if repo.ui.debugflag:
            msg = 'invalid branchheads cache'
            if repo.filtername is not None:
                msg += ' (%s)' % repo.filtername
            msg += ': %s\n'
            repo.ui.debug(msg % inst)
        partial = None
    return partial

def modsetup(ui):
    """call at uisetup time to install various wrappings"""
    extensions.wrapfunction(changegroup.cg1unpacker, 'apply', cgapply)
    extensions.wrapfunction(cmdutil, 'commitstatus', commitstatus)