from mercurial import error

from mercurial import util

from mercurial import destutil

from mercurial import extensions

from mercurial.i18n import _

def _destmergebranch(orig, repo):

    p1 = repo['.']

    top = p1.topic()

    if top:

        heads = repo.revs('heads(topic(.)::topic(.))')

        if p1.rev() not in heads:

            raise error.Abort(_("not at topic head, update or explicit"))

        elif 1 == len(heads):

            # should look at all branch involved but... later

            bhead = ngtip(repo, p1.branch(), all=True)

            if not bhead:

                raise error.Abort(_("nothing to merge"))

            elif 1 == len(bhead):

                return bhead.first()

            else:

                raise error.Abort(_("branch '%s' has %d heads - "

                                   "please merge with an explicit rev")

                                 % (p1.branch(), len(bhead)),

                                 hint=_("run 'hg heads .' to see heads"))

        elif 2 == len(heads):

            heads = [r for r in heads if r != p1.rev()]

            # XXX: bla bla bla bla bla

            if 1 < len(heads):

                raise error.Abort(_('working directory not at a head revision'),

                                 hint=_("use 'hg update' or merge with an "

                                        "explicit revision"))

            return heads[0]

        elif 2 < len(heads):

            raise error.Abort(_("topic '%s' has %d heads - "

                                "please merge with an explicit rev")

                              % (top, len(heads)))

        else:

            assert False # that's impossible

    return orig(repo)

def setupdest():

    if util.safehasattr(destutil, '_destmergebranch'):

        extensions.wrapfunction(destutil, '_destmergebranch', _destmergebranch)

def ngtip(repo, branch, all=False):

    """tip new generation"""

    ## search for untopiced heads of branch

    # could be heads((::branch(x) - topic()))

    # but that is expensive

    #

    # we should write plain code instead

    subquery = '''heads(

                    parents(

                       ancestor(

                         (head() and branch(%s)

                         or (topic() and branch(%s)))))

                   ::(head() and branch(%s))

                   - topic())'''

    if not all:

        subquery = 'max(%s)' % subquery

    return repo.revs(subquery, branch, branch, branch)