# destutil.py - Mercurial utility function for command destination

#

#  Copyright Matt Mackall <mpm@selenic.com> and other

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

from .i18n import _

def orphanpossibledestination(repo, rev):

    """Return all changesets that may be a new parent for orphan `rev`.

    This function works fine on non-orphan revisions, it's just silly

    because there's no destination implied by obsolete markers, so

    it'll return nothing.

    """

    tonode = repo.changelog.node

    parents = repo.changelog.parentrevs

    torev = repo.changelog.rev

    dest = set()

    tovisit = list(parents(rev))

    while tovisit:

        r = tovisit.pop()

        succsets = obsutil.successorssets(repo, tonode(r))

        if not succsets:

            # if there are no successors for r, r was probably pruned

            # and we should walk up to r's parents to try and find

            # some successors.

            tovisit.extend(parents(r))

        else:

            # We should probably pick only one destination from split

            # (case where '1 < len(ss)'), This could be the currently

            # tipmost, but the correct result is less clear when

            # results of the split have been moved such that they

            # reside on multiple branches.

            for ss in succsets:

                for n in ss:

                    dr = torev(n)

                    if dr != -1:

                        dest.add(dr)

    return dest

def _destupdateobs(repo, clean):

    """decide of an update destination from obsolescence markers"""

    node = None

    wc = repo[None]

    p1 = wc.p1()

    movemark = None

    if p1.obsolete() and not p1.children():

        # allow updating to successors

        successors = obsutil.successorssets(repo, p1.node())

        # behavior of certain cases is as follows,

        #

        # divergent changesets: update to highest rev, similar to what

        #     is currently done when there are more than one head

        #     (i.e. 'tip')

        #

        # replaced changesets: same as divergent except we know there

        # is no conflict

        #

        # pruned changeset: no update is done; though, we could

        #     consider updating to the first non-obsolete parent,

        #     similar to what is current done for 'hg prune'

        if successors:

            # flatten the list here handles both divergent (len > 1)

            # and the usual case (len = 1)

            successors = [n for sub in successors for n in sub]

            # get the max revision for the given successors set,

            # i.e. the 'tip' of a set

            node = repo.revs('max(%ln)', successors).first()

            if bookmarks.isactivewdirparent(repo):

                movemark = repo['.'].node()

    return node, movemark, None

def _destupdatebook(repo, clean):

    """decide on an update destination from active bookmark"""

    # we also move the active bookmark, if any

    node = None

    activemark, movemark = bookmarks.calculateupdate(repo.ui, repo)

    if activemark is not None:

        node = repo._bookmarks[activemark]

    return node, movemark, activemark

def _destupdatebranch(repo, clean):

    """decide on an update destination from current branch

    This ignores closed branch heads.

    """

    wc = repo[None]

    movemark = node = None

    currentbranch = wc.branch()

    if clean:

        currentbranch = repo['.'].branch()

    if currentbranch in repo.branchmap():

        heads = repo.branchheads(currentbranch)

        if heads:

            node = repo.revs('max(.::(%ln))', heads).first()

        if bookmarks.isactivewdirparent(repo):

            movemark = repo['.'].node()

    elif currentbranch == 'default' and not wc.p1():

        # "null" parent belongs to "default" branch, but it doesn't exist, so

        # update to the tipmost non-closed branch head

        node = repo.revs('max(head() and not closed())').first()

    else:

        node = repo['.'].node()

    return node, movemark, None

def _destupdatebranchfallback(repo, clean):

    """decide on an update destination from closed heads in current branch"""

    wc = repo[None]

    currentbranch = wc.branch()

    movemark = None

    if currentbranch in repo.branchmap():

        # here, all descendant branch heads are closed

        heads = repo.branchheads(currentbranch, closed=True)

        assert heads, "any branch has at least one head"

        node = repo.revs('max(.::(%ln))', heads).first()

        if bookmarks.isactivewdirparent(repo):

            movemark = repo['.'].node()

    else:

        # here, no "default" branch, and all branches are closed

        node = repo.lookup('tip')

        assert node is not None, "'tip' exists even in empty repository"

    return node, movemark, None

# order in which each step should be evaluated

# steps are run until one finds a destination

destupdatesteps = ['evolution', 'bookmark', 'branch', 'branchfallback']

# mapping to ease extension overriding steps.

def destupdate(repo, clean=False):

    """destination for bare update operation

    return (rev, movemark, activemark)

    - rev: the revision to update to,

    - movemark: node to move the active bookmark from

                (cf bookmark.calculate update),

    - activemark: a bookmark to activate at the end of the update.

    """

    node = movemark = activemark = None

    for step in destupdatesteps:

        node, movemark, activemark = destupdatestepmap[step](repo, clean)

        if node is not None:

            break

    rev = repo[node].rev()

    return rev, movemark, activemark

msgdestmerge = {

    # too many matching divergent bookmark

    # no other matching divergent bookmark

    # branch have too many unbookmarked heads, no obvious destination

    # branch have no other unbookmarked heads

    # branch have just a single heads, but there is other branches

    # repository have a single head

    # repository have a single head and we are not on it

    # We are not on a head

def _destmergebook(repo, action='merge', sourceset=None, destspace=None):

    """find merge destination in the active bookmark case"""

    node = None

    bmheads = bookmarks.headsforactive(repo)

    curhead = repo._bookmarks[repo._activebookmark]

    if len(bmheads) == 2:

        if curhead == bmheads[0]:

            node = bmheads[1]

        else:

            node = bmheads[0]

    elif len(bmheads) > 2:

        msg, hint = msgdestmerge['toomanybookmarks'][action]

        raise error.ManyMergeDestAbort(msg, hint=hint)

    elif len(bmheads) <= 1:

        msg, hint = msgdestmerge['nootherbookmarks'][action]

        raise error.NoMergeDestAbort(msg, hint=hint)

    assert node is not None

    return node

    """find merge destination based on branch heads"""

    node = None

    if sourceset is None:

        sourceset = [repo[repo.dirstate.p1()].rev()]

        branch = repo.dirstate.branch()

    elif not sourceset:

        msg, hint = msgdestmerge['emptysourceset'][action]

        raise error.NoMergeDestAbort(msg, hint=hint)

    else:

        branch = None

        for ctx in repo.set('roots(%ld::%ld)', sourceset, sourceset):

            if branch is not None and ctx.branch() != branch:

                msg, hint = msgdestmerge['multiplebranchessourceset'][action]

                raise error.ManyMergeDestAbort(msg, hint=hint)

            branch = ctx.branch()

    bheads = repo.branchheads(branch)

    onhead = repo.revs('%ld and %ln', sourceset, bheads)

    if onheadcheck and not onhead:

        # Case A: working copy if not on a head. (merge only)

        #

        # This is probably a user mistake We bailout pointing at 'hg update'

        if len(repo.heads()) <= 1:

            msg, hint = msgdestmerge['nootherheadsbehind'][action]

        else:

            msg, hint = msgdestmerge['notatheads'][action]

        raise error.Abort(msg, hint=hint)

    # remove heads descendants of source from the set

    bheads = list(repo.revs('%ln - (%ld::)', bheads, sourceset))

    # filters out bookmarked heads

    nbhs = list(repo.revs('%ld - bookmark()', bheads))

    if destspace is not None:

        # restrict search space

        # used in the 'hg pull --rebase' case, see issue 5214.

        nbhs = list(repo.revs('%ld and %ld', destspace, nbhs))

    if len(nbhs) > 1:

        # Case B: There is more than 1 other anonymous heads

        #

        # This means that there will be more than 1 candidate. This is

        # ambiguous. We abort asking the user to pick as explicit destination

        # instead.

        msg, hint = msgdestmerge['toomanyheads'][action]

        msg %= (branch, len(bheads) + 1)

        raise error.ManyMergeDestAbort(msg, hint=hint)

    elif not nbhs:

        # Case B: There is no other anonymous heads

        #

        # This means that there is no natural candidate to merge with.

        # We abort, with various messages for various cases.

        if bheads:

            msg, hint = msgdestmerge['bookmarkedheads'][action]

        elif len(repo.heads()) > 1:

            msg, hint = msgdestmerge['nootherbranchheads'][action]

            msg %= branch

        elif not onhead:

            # if 'onheadcheck == False' (rebase case),

            # this was not caught in Case A.

            msg, hint = msgdestmerge['nootherheadsbehind'][action]

        else:

            msg, hint = msgdestmerge['nootherheads'][action]

        raise error.NoMergeDestAbort(msg, hint=hint)

    else:

        node = nbhs[0]

    assert node is not None

    return node

    """return the default destination for a merge

    (or raise exception about why it can't pick one)

    :action: the action being performed, controls emitted error message

    """

    # destspace is here to work around issues with `hg pull --rebase` see

    # issue5214 for details

    if repo._activebookmark:

    else:

    return repo[node].rev()

def desthistedit(ui, repo):

    """Default base revision to edit for `hg histedit`."""

    default = ui.config('histedit', 'defaultrev')

    if default is None:

        revs = stack.getstack(repo)

    elif default:

        revs = scmutil.revrange(repo, [default])

    else:

        raise error.Abort(_("config option histedit.defaultrev can't be empty"))

    if revs:

        # Take the first revision of the revset as the root

        return revs.min()

    return None

def stackbase(ui, repo):

    revs = stack.getstack(repo)

    return revs.first() if revs else None

def _statusotherbook(ui, repo):

    bmheads = bookmarks.headsforactive(repo)

    curhead = repo._bookmarks[repo._activebookmark]

    if repo.revs('%n and parents()', curhead):

        # we are on the active bookmark

        bmheads = [b for b in bmheads if curhead != b]

        if bmheads:

            msg = _('%i other divergent bookmarks for "%s"\n')

            ui.status(msg % (len(bmheads), repo._activebookmark))

def _statusotherbranchheads(ui, repo):

    currentbranch = repo.dirstate.branch()

    allheads = repo.branchheads(currentbranch, closed=True)

    heads = repo.branchheads(currentbranch)

    if repo.revs('%ln and parents()', allheads):

        # we are on a head, even though it might be closed

        #

        #  on closed otherheads

        #  ========= ==========

        #      o        0       all heads for current branch are closed

        #               N       only descendant branch heads are closed

        #      x        0       there is only one non-closed branch head

        #               N       there are some non-closed branch heads

        #  ========= ==========

        otherheads = repo.revs('%ln - parents()', heads)

        if repo['.'].closesbranch():

            if otherheads:

            else:

        elif otherheads:

            curhead = repo['.']

def statusotherdests(ui, repo):

    """Print message about other head"""

    # XXX we should probably include a hint:

    # - about what to do

    # - how to see such heads

    if repo._activebookmark:

        _statusotherbook(ui, repo)

    else: