# 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,

    copies,

    error,

    hg,

    lock as lockmod,

    merge,

    node,

    obsolete,

    obsutil,

    phases,

    repair,

    scmutil,

    util,

)

from mercurial.i18n import _

from . import (

    cmdrewrite,

    compat,

    exthelper,

    rewriteutil,

    state,

    utility,

)

TROUBLES = compat.TROUBLES

shorttemplate = utility.shorttemplate

_bookmarksupdater = rewriteutil.bookmarksupdater

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

eh = exthelper.exthelper()

mergetoolopts = commands.mergetoolopts

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

              progresscb, category):

    """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 node, when resolution led to no new

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

    """

    wlock = lock = tr = None

    try:

        wlock = repo.wlock()

        lock = repo.lock()

        tr = repo.transaction("evolve")

        if 'orphan' == category:

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

                                    dryrun, confirm, progresscb)

        elif 'phasedivergent' == category:

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

                                           dryrun, confirm, progresscb)

        elif 'contentdivergent' == category:

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

                                     dryrun, confirm, progresscb)

        else:

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

        tr.close()

        return result

    finally:

        lockmod.release(tr, lock, wlock)

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

                   progresscb=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['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(_("cannot solve instability of %s, skipping\n") % orig)

        return (False, '')

    obs = pctx

    newer = obsutil.successorssets(repo, obs.node())

    # search of a parent which is not killed

    while not newer or newer == [()]:

        ui.debug("stabilize target %s is plain dead,"

                 " trying to stabilize on its parent\n" %

                 obs)

        obs = obs.parents()[0]

        newer = obsutil.successorssets(repo, obs.node())

    if len(newer) > 1:

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

                "destination\n") % obs

        ui.write_err(msg)

        return (False, '')

    targets = newer[0]

    assert targets

    if len(targets) > 1:

        # split target, figure out which one to pick, are they all in line?

        targetrevs = [repo[r].rev() for r in targets]

        roots = repo.revs('roots(%ld)', targetrevs)

        heads = repo.revs('heads(%ld)', targetrevs)

        if len(roots) > 1 or len(heads) > 1:

            cheader = _("ancestor '%s' split over multiple topological"

                        " branches.\nchoose an evolve destination:") % orig

            selectedrev = utility.revselectionprompt(ui, repo, list(heads),

                                                     cheader)

            if selectedrev is None:

                msg = _("could not solve instability, "

                        "ambiguous destination: "

                        "parent split across two branches\n")

                ui.write_err(msg)

                return (False, '')

            target = repo[selectedrev]

        else:

            target = repo[heads.first()]

    else:

        target = targets[0]

    displayer = compat.changesetdisplayer(ui, repo, {'template': shorttemplate})

    target = repo[target]

    if not ui.quiet or confirm:

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

        displayer.show(orig)

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

        displayer.show(target)

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

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

    if progresscb:

        progresscb()

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

    if dryrun:

        repo.ui.write(todo)

        return (False, '')

    else:

        repo.ui.note(todo)

        if progresscb:

            progresscb()

        try:

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

                             keepbranch, 'orphan')

            return (True, newid)

        except MergeFailure:

            ops = {'current': orig.node()}

            evolvestate.addopts(ops)

            evolvestate.save()

            repo.ui.write_err(_('evolve failed!\n'))

            repo.ui.write_err(

                _("fix conflict and run 'hg evolve --continue'"

                  " or use 'hg evolve --abort' to abort\n"))

            raise

def _solvephasedivergence(ui, repo, bumped, evolvestate, 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 = _('skipping %s : we do not handle merge yet\n') % bumped

        ui.write_err(msg)

        return (False, '')

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

    # For now we deny target merge

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

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

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

        ui.write_err(msg)

        return (False, '')

    displayer = compat.changesetdisplayer(ui, repo, {'template': shorttemplate})

    if not ui.quiet or confirm:

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

        displayer.show(bumped)

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

        displayer.show(prec)

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

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

    if dryrun:

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

        repo.ui.write(todo)

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

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

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

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

        return (False, '')

    if progresscb:

        progresscb()

    tmpctx = bumped

    # 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, grabbed, 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('parents(%d) and parents(%d)', bumped.rev(), prec.rev())):

        # Need to rebase the changeset at the right place

        repo.ui.status(

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

        try:

            tmpid = relocate(repo, bumped, prec.p1(), evolvestate,

                             category='phasedivergent')

            if tmpid is not None:

                tmpctx = repo[tmpid]

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

                                       operation='evolve')

        except MergeFailure:

            evolvestate['current'] = bumped.hex()

            evolvestate['precursor'] = prec.hex()

            evolvestate.save()

            repo.ui.write_err(_('evolution failed!\n'))

            msg = _("fix conflict then run 'hg evolve --continue' or "

                    "use `hg evolve --abort`\n")

            repo.ui.write_err(msg)

            raise

    return _resolvephasedivergent(ui, repo, prec, bumped, tmpctx)

def _resolvephasedivergent(ui, repo, prec, bumped, tmpctx=None):

    tr = repo.currenttransaction()

    assert tr is not None

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

    newid = None

    # function to update the bookmark from the rebased changeset to new resolved

    # changeset

    rebasedbmupdate = None

    if tmpctx and tmpctx.node() != bumped.node():

        rebasedbmupdate = _bookmarksupdater(repo, tmpctx.node(), tr)

        bumped = tmpctx

    # Create the new commit context

    repo.ui.status(_('computing new diff\n'))

    files = set()

    copied = copies.pathcopies(prec, bumped)

    precmanifest = prec.manifest().copy()

    # 3.3.2 needs a list.

    # future 3.4 don't detect the size change during iteration

    # this is fishy

    for key, val in list(bumped.manifest().iteritems()):

        precvalue = precmanifest.get(key, None)

        if precvalue is not None:

            del precmanifest[key]

        if precvalue != val:

            files.add(key)

    files.update(precmanifest)  # add missing files

    # commit it

    if files: # something to commit!

        def filectxfn(repo, ctx, path):

            if path in bumped:

                fctx = bumped[path]

                flags = fctx.flags()

                mctx = compat.memfilectx(repo, ctx, fctx, flags, copied, path)

                return mctx

            return None

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

        text += bumped.description()

        new = context.memctx(repo,

                             parents=[prec.node(), node.nullid],

                             text=text,

                             files=files,

                             filectxfn=filectxfn,

                             user=bumped.user(),

                             date=bumped.date(),

                             extra=bumped.extra())

        newid = repo.commitctx(new)

    if newid is None:

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

        newid = prec.node()

    else:

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

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

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

    bmupdate(newid)

    # if rebased happened, update bookmarks from there too

    if rebasedbmupdate:

        rebasedbmupdate(newid)

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

    # reroute the working copy parent to the new changeset

    with repo.dirstate.parentchange():

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

    return (True, newid)

def _solvedivergent(ui, repo, divergent, evolvestate, dryrun=False,

                    confirm=False, progresscb=None):

    """tries to solve content-divergence of a 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()

    divergent = repo[divergent.rev()]

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

    base, others = divergentdata(divergent)

    if len(others) > 1:

        othersstr = "[%s]" % (','.join([str(i) for i in others]))

        msg = _("skipping %d:%s with a changeset that got split"

                " into multiple ones:\n"

                "|[%s]\n"

                "| This is not handled by automatic evolution yet\n"

                "| You have to fallback to manual handling with commands "

                "such as:\n"

                "| - hg touch -D\n"

                "| - hg prune\n"

                "| \n"

                "| You should contact your local evolution Guru for help.\n"

                ) % (divergent, TROUBLES['CONTENTDIVERGENT'], othersstr)

        ui.write_err(msg)

        return (False, '')

    other = others[0]

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

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

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

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

        ui.write_err(msg)

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

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

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

        ui.write_err(hint)