# Copyright 2011 Peter Arrenbrecht <peter.arrenbrecht@gmail.com>

#                Logilab SA        <contact@logilab.fr>

#                Pierre-Yves David <pierre-yves.david@ens-lyon.org>

#                Patrick Mezard <patrick@mezard.eu>

#

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

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

"""logic related to hg evolve command"""

import collections

import re

from mercurial import (

    bookmarks as bookmarksmod,

    cmdutil,

    commands,

    context,

    encoding,

    error,

    hg,

    logcmdutil,

    merge,

    mergeutil,

    node as nodemod,

    obsolete,

    obsutil,

    phases,

    pycompat,

    repair,

    scmutil,

    simplemerge,

    util,

)

from mercurial.i18n import _

from . import (

    cmdrewrite,

    compat,

    exthelper,

    rewriteutil,

    state,

    utility,

)

TROUBLES = compat.TROUBLES

shorttemplate = utility.shorttemplate

stacktemplate = utility.stacktemplate

_bookmarksupdater = rewriteutil.bookmarksupdater

sha1re = re.compile(br'\b[0-9a-f]{6,40}\b')

eh = exthelper.exthelper()

mergetoolopts = commands.mergetoolopts

abortmessage = _(b"see `hg help evolve.interrupted`\n")

def _solveone(ui, repo, ctx, evolvestate, dryrun, confirm,

              progresscb, category, lastsolved=None, stacktmplt=False):

    """Resolve the troubles affecting one revision

    returns a tuple (bool, newnode) where,

        bool: a boolean value indicating whether the instability was solved

        newnode: if bool is True, then the newnode of the resultant commit

                 formed. newnode can be None, when resolution led to no new

                 commit. If bool is False, this is ".".

    """

    tr = repo.currenttransaction()

    assert tr is not None

    displayer = None

    if stacktmplt:

        displayer = logcmdutil.changesetdisplayer(ui, repo,

                                                  {b'template': stacktemplate})

    else:

        displayer = logcmdutil.changesetdisplayer(ui, repo,

                                                  {b'template': shorttemplate})

    if b'orphan' == category:

        result = _solveunstable(ui, repo, ctx, evolvestate, displayer,

                                dryrun, confirm, progresscb,

                                lastsolved=lastsolved)

    elif b'phasedivergent' == category:

        result = _solvephasedivergence(ui, repo, ctx, evolvestate,

                                       displayer, dryrun, confirm,

                                       progresscb)

    elif b'contentdivergent' == category:

        result = _solvedivergent(ui, repo, ctx, evolvestate, displayer,

                                 dryrun, confirm, progresscb)

    else:

        assert False, b"unknown trouble category: %s" % (category)

    return result

def _solveunstable(ui, repo, orig, evolvestate, displayer, dryrun=False,

                   confirm=False, progresscb=None, lastsolved=None):

    """ Tries to stabilize the changeset orig which is orphan.

    returns a tuple (bool, newnode) where,

        bool: a boolean value indicating whether the instability was solved

        newnode: if bool is True, then the newnode of the resultant commit

                 formed. newnode can be node, when resolution led to no new

                 commit. If bool is False, this is ".".

    """

    pctx = orig.p1()

    keepbranch = orig.p1().branch() != orig.branch()

    if len(orig.parents()) == 2:

        p1obs = orig.p1().obsolete()

        p2obs = orig.p2().obsolete()

        if not p1obs and p2obs:

            pctx = orig.p2()  # second parent is obsolete ?

            keepbranch = orig.p2().branch() != orig.branch()

        elif not p2obs and p1obs:

            pass

        else:

            # store that we are resolving an orphan merge with both parents

            # obsolete and proceed with first parent

            evolvestate[b'orphanmerge'] = True

            # we should process the second parent first, so that in case of

            # no-conflicts the first parent is processed later and preserved as

            # first parent

            pctx = orig.p2()

            keepbranch = orig.p2().branch() != orig.branch()

    if not pctx.obsolete():

        ui.warn(_(b"cannot solve instability of %s, skipping\n") % orig)

        return (False, b".")

    obs = pctx

    try:

        newer = utility._singlesuccessor(repo, obs)

        # search of a parent which isn't the orig

        while repo[newer].node() == orig.node():

            obs = obs.parents()[0]

            newer = utility._singlesuccessor(repo, obs)

    except utility.MultipleSuccessorsError as exc:

        if exc.divergenceflag:

            msg = _(b"skipping %s: divergent rewriting. can't choose "

                    b"destination\n") % obs

            ui.write_err(msg)

            return (False, b".")

        if exc.splitflag:

            splitsucc = utility.picksplitsuccessor(ui, repo, obs, orig)

            if not splitsucc[0]:

                msg = _(b"could not solve instability, "

                        b"ambiguous destination: "

                        b"parent split across two branches\n")

                ui.write_err(msg)

                return (False, b".")

            newer = splitsucc[1]

    target = repo[newer]

    if not ui.quiet or confirm:

        repo.ui.write(_(b'move:'), label=b'evolve.operation')

        displayer.show(orig)

        if lastsolved is None or target != repo[lastsolved]:

            repo.ui.write(_(b'atop:'))

            displayer.show(target)

    if confirm and ui.prompt(b'perform evolve? [Ny]', b'n') != b'y':

        raise error.Abort(_(b'evolve aborted by user'))

    todo = b'hg rebase -r %s -d %s\n' % (orig, target)

    if dryrun:

        if progresscb:

            progresscb()

        repo.ui.write(todo)

        return (False, b".")

    else:

        repo.ui.note(todo)

        if progresscb:

            progresscb()

        with state.saver(evolvestate, {b'current': orig.node()}):

            newid = _relocate(repo, orig, target, evolvestate, pctx,

                              keepbranch, b'orphan')

            return (True, newid)

def _solvephasedivergence(ui, repo, bumped, evolvestate, displayer,

                          dryrun=False, confirm=False, progresscb=None):

    """Stabilize a phase divergent changeset

    returns a tuple (bool, newnode) where,

        bool: a boolean value indicating whether the instability was solved

        newnode: if bool is True, then the newnode of the resultant commit

                 formed. newnode can be node, when resolution led to no new

                 commit. If bool is False, this is ".".

    """

    repo = repo.unfiltered()

    bumped = repo[bumped.rev()]

    # For now we deny bumped merge

    if len(bumped.parents()) > 1:

        msg = _(b'skipping %s : we do not handle merge yet\n') % bumped

        ui.write_err(msg)

        return (False, b".")

    prec = next(repo.set(b'last(allpredecessors(%d) and public())', bumped.rev()))

    # For now we deny target merge

    if len(prec.parents()) > 1:

        msg = _(b'skipping: %s: public version is a merge, '

                b'this is not handled yet\n') % prec

        ui.write_err(msg)

        return (False, b".")

    if not ui.quiet or confirm:

        repo.ui.write(_(b'recreate:'), label=b'evolve.operation')

        displayer.show(bumped)

        repo.ui.write(_(b'atop:'))

        displayer.show(prec)

    if confirm and ui.prompt(_(b'perform evolve? [Ny]'), b'n') != b'y':

        raise error.Abort(_(b'evolve aborted by user'))

    if dryrun:

        todo = b'hg rebase --rev %s --dest %s;\n' % (bumped, prec.p1())

        repo.ui.write(todo)

        repo.ui.write((b'hg update %s;\n' % prec))

        repo.ui.write((b'hg revert --all --rev %s;\n' % bumped))

        repo.ui.write((b'hg commit --msg "%s update to %s"\n' %

                       (TROUBLES['PHASEDIVERGENT'], bumped)))

        return (False, b".")

    if progresscb:

        progresscb()

    # Checking for whether the phase-divergent changeset has common parents as

    # it's precursors. Phase-divergent changeset and precursor having different

    # parents is a result of when the changeset is rebased, picked, histedit or

    # evolved or any other operation which can change parent. In such cases,

    # when parents are not same, we first rebase the divergent changeset onto

    # parent or precursor and then perform later steps

    if not list(repo.set(b'parents(%d) and parents(%d)', bumped.rev(), prec.rev())):

        # Need to rebase the changeset at the right place

        repo.ui.status(

            _(b'rebasing to destination parent: %s\n') % prec.p1())

        with state.saver(evolvestate, {b'current': bumped.hex(),

                                       b'precursor': prec.hex()}):

            newnode = _relocate(repo, bumped, prec.p1(), evolvestate,

                                category=b'phasedivergent')

            if newnode is not None:

                new = repo[newnode]

                obsolete.createmarkers(repo, [(bumped, (new,))],

                                       operation=b'evolve')

                bumped = new

                evolvestate[b'temprevs'].append(newnode)

    return _resolvephasedivergent(ui, repo, prec, bumped)

def _resolvephasedivergent(ui, repo, prec, bumped):

    """final step of a phase divergence resolution

    This will create a new changesets (or nothing when applicable), the two

    changesets needs to be on the same parents.

    """

    tr = repo.currenttransaction()

    assert tr is not None

    cl = repo.changelog

    prec_parent = cl.parentrevs(prec.rev())

    bump_parent = cl.parentrevs(bumped.rev())

    assert prec_parent == bump_parent, (prec_parent, bump_parent)

    bmupdate = _bookmarksupdater(repo, bumped.node(), tr)

    newid = None

    replacementnode = None

    # Create the new commit context. This is done by applying the changes from

    # the precursor to the bumped node onto the precursor. This is effectively

    # like reverting to the bumped node.

    wctx = context.overlayworkingctx(repo)

    wctx.setbase(prec)

    merge.update(repo, bumped.node(), ancestor=prec, mergeancestor=True,

                 branchmerge=True, force=False, wc=wctx)

    if not wctx.isempty():

        text = b'%s update to %s:\n\n' % (TROUBLES['PHASEDIVERGENT'], prec)

        text += bumped.description()

        memctx = wctx.tomemctx(text,

                               parents=(prec.node(), nodemod.nullid),

                               branch=bumped.branch(),

                               date=bumped.date(),

                               extra=bumped.extra(),

                               user=bumped.user())

        newid = repo.commitctx(memctx)

        replacementnode = newid

    if newid is None:

        repo.ui.status(_(b'no changes to commit\n'))

        obsolete.createmarkers(repo, [(bumped, ())], operation=b'evolve')

        newid = prec.node()

    else:

        repo.ui.status(_(b'committed as %s\n') % nodemod.short(newid))

        phases.retractboundary(repo, tr, bumped.phase(), [newid])

        obsolete.createmarkers(repo, [(bumped, (repo[newid],))],

                               flag=obsolete.bumpedfix, operation=b'evolve')

    bmupdate(newid)

    # reroute the working copy parent to the new changeset

    with repo.dirstate.parentchange(), compat.parentchange(repo):

        repo.dirstate.setparents(newid, nodemod.nullid)

    return (True, replacementnode)

def _prepcontentdivresolution(ui, repo, divergent, other, evolvestate):

    """ if relocation required, decide which divergent cset will be relocated

    to the other side"""

    divergent = repo[divergent.rev()]

    evolvestate[b'divergent'] = divergent.node()

    evolvestate[b'orig-divergent'] = divergent.node()

    # sometimes we will relocate a node in case of different parents and we can

    # encounter conflicts after relocation is done while solving

    # content-divergence and if the user calls `hg evolve --stop`, we need to

    # strip that relocated commit. However if `--all` is passed, we need to

    # reset this value for each content-divergence resolution which we are doing

    # below.

    evolvestate[b'relocated-other'] = None

    evolvestate[b'relocating-other'] = False

    evolvestate[b'relocated-div'] = None

    evolvestate[b'relocating-div'] = False

    evolvestate[b'relocation-req'] = False

    # in case or relocation we get a new other node, we need to store the old

    # other for purposes like `--abort` or `--stop`

    evolvestate[b'old-other'] = None

    evolvestate[b'old-divergent'] = None

    def swapnodes(div, other):

        div, other = other, div

        evolvestate[b'divergent'] = div.node()

        evolvestate[b'other-divergent'] = other.node()

        return div, other

    # haspubdiv: to keep track if we are solving public content-divergence

    haspubdiv = False

    if not (divergent.mutable() and other.mutable()):

        haspubdiv = True

        # for simplicity, we keep public one to local side while merging

        # (as divergent is kept at local side, pinning public -> divergent)

        if divergent.mutable():

            publicdiv = other

            divergent, other = swapnodes(divergent, other)

        else:

            publicdiv = divergent

        evolvestate[b'public-divergent'] = publicdiv.node()

    # we don't handle merge content-divergent changesets yet

    if len(other.parents()) > 1:

        msg = _(b"skipping %s: %s changeset can't be "

                b"a merge (yet)\n") % (divergent, TROUBLES['CONTENTDIVERGENT'])

        ui.write_err(msg)

        hint = _(b"You have to fallback to solving this by hand...\n"

                 b"| This probably means redoing the merge and using \n"

                 b"| `hg prune` to kill older version.\n")

        ui.write_err(hint)

        return (False, b".")

    otherp1 = succsotherp1 = other.p1().rev()

    divp1 = succsdivp1 = divergent.p1().rev()

    # finding single successors of otherp1 and divp1

    try:

        succsotherp1 = utility._singlesuccessor(repo, other.p1())

    except utility.MultipleSuccessorsError:

        pass

    try:

        succsdivp1 = utility._singlesuccessor(repo, divergent.p1())

    except utility.MultipleSuccessorsError:

        pass

    # the changeset on which resolution changeset will be based on

    resolutionparent = repo[succsdivp1].node()

    # the nullrev has to be handled specially because -1 is overloaded to both

    # mean nullrev (this meaning is used for the result of changectx.rev(), as

    # called above) and the tipmost revision (this meaning is used for the %d

    # format specifier, as used below)

    if nodemod.nullrev in (succsotherp1, succsdivp1):

        # nullrev is the only possible ancestor if succsotherp1 or succsdivp1 is nullrev