# states.py - introduce the state concept for mercurial changeset

#

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

#                Logilab SA        <contact@logilab.fr>

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

#

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

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

'''a set of commands to handle changeset mutation'''

import random

from mercurial import cmdutil

from mercurial import scmutil

from mercurial import node

from mercurial import error

from mercurial import extensions

from mercurial import commands

from mercurial import bookmarks

from mercurial import phases

from mercurial import context

from mercurial import copies

from mercurial import util

from mercurial.i18n import _

from mercurial.commands import walkopts, commitopts, commitopts2

from mercurial import hg

### util function

#############################

def noderange(repo, revsets):

    """The same as revrange but return node"""

    return map(repo.changelog.node,

               scmutil.revrange(repo, revsets))

### changeset rewriting logic

#############################

def rewrite(repo, old, updates, head, newbases, commitopts):

    """Return (nodeid, created) where nodeid is the identifier of the

    changeset generated by the rewrite process, and created is True if

    nodeid was actually created. If created is False, nodeid

    references a changeset existing before the rewrite call.

    """

    if len(old.parents()) > 1: #XXX remove this unecessary limitation.

        raise error.Abort(_('cannot amend merge changesets'))

    base = old.p1()

    updatebookmarks = _bookmarksupdater(repo, old.node())

    wlock = repo.wlock()

    try:

        # commit a new version of the old changeset, including the update

        # collect all files which might be affected

        files = set(old.files())

        for u in updates:

            files.update(u.files())

        # Recompute copies (avoid recording a -> b -> a)

        copied = copies.pathcopies(base, head)

        # prune files which were reverted by the updates

        def samefile(f):

            if f in head.manifest():

                a = head.filectx(f)

                if f in base.manifest():

                    b = base.filectx(f)

                    return (a.data() == b.data()

                            and a.flags() == b.flags())

                else:

                    return False

            else:

                return f not in base.manifest()

        files = [f for f in files if not samefile(f)]

        # commit version of these files as defined by head

        headmf = head.manifest()

        def filectxfn(repo, ctx, path):

            if path in headmf:

                fctx = head[path]

                flags = fctx.flags()

                mctx = context.memfilectx(fctx.path(), fctx.data(),

                                          islink='l' in flags,

                                          isexec='x' in flags,

                                          copied=copied.get(path))

                return mctx

            raise IOError()

        if commitopts.get('message') and commitopts.get('logfile'):

            raise util.Abort(_('options --message and --logfile are mutually'

                               ' exclusive'))

        if commitopts.get('logfile'):

            message= open(commitopts['logfile']).read()

        elif commitopts.get('message'):

            message = commitopts['message']

        else:

            message = old.description()

        user = commitopts.get('user') or old.user()

        date = commitopts.get('date') or None # old.date()

        extra = dict(commitopts.get('extra', {}))

        extra['branch'] = head.branch()

        new = context.memctx(repo,

                             parents=newbases,

                             text=message,

                             files=files,

                             filectxfn=filectxfn,

                             user=user,

                             date=date,

                             extra=extra)

        if commitopts.get('edit'):

            new._text = cmdutil.commitforceeditor(repo, new, [])

        revcount = len(repo)

        newid = repo.commitctx(new)

        new = repo[newid]

        created = len(repo) != revcount

        if created:

            updatebookmarks(newid)

            # add evolution metadata

            markers = [(u, (new,)) for u in updates]

            markers.append((old, (new,)))

            obsolete = extensions.find('obsolete')

            obsolete.createmarkers(repo, markers)

        else:

            # newid is an existing revision. It could make sense to

            # replace revisions with existing ones but probably not by

            # default.

            pass

    finally:

        wlock.release()

    return newid, created

class MergeFailure(util.Abort):

    pass

def relocate(repo, orig, dest):

    """rewrite <rev> on dest"""

    try:

        rebase = extensions.find('rebase')

        # dummy state to trick rebase node

        assert orig.p2().rev() == node.nullrev, 'no support yet'

        destbookmarks = repo.nodebookmarks(dest.node())

        cmdutil.duplicatecopies(repo, orig.node(), dest.node())

        nodesrc = orig.node()

        destphase = repo[nodesrc].phase()

        if rebase.rebasenode.func_code.co_argcount == 5:

            # rebasenode collapse argument was introduced by

            # d1afbf03e69a (2.3)

            rebase.rebasenode(repo, orig.node(), dest.node(),

                              {node.nullrev: node.nullrev}, False)

        else:

            rebase.rebasenode(repo, orig.node(), dest.node(),

                              {node.nullrev: node.nullrev})

        try:

            nodenew = rebase.concludenode(repo, orig.node(), dest.node(),

                                          node.nullid)

        except util.Abort, exc:

            class LocalMergeFailure(MergeFailure, exc.__class__):

                pass

            exc.__class__ = LocalMergeFailure

            raise

        oldbookmarks = repo.nodebookmarks(nodesrc)

        obsolete = extensions.find('obsolete')

        if nodenew is not None:

            phases.retractboundary(repo, destphase, [nodenew])

            obsolete.createmarkers(repo, [(repo[nodesrc], (repo[nodenew],))])

            for book in oldbookmarks:

                repo._bookmarks[book] = nodenew

        else:

            obsolete.createmarkers(repo, [(repo[nodesrc], ())])

            # Behave like rebase, move bookmarks to dest

            for book in oldbookmarks:

                repo._bookmarks[book] = dest.node()

        for book in destbookmarks: # restore bookmark that rebase move

            repo._bookmarks[book] = dest.node()

        if oldbookmarks or destbookmarks:

            bookmarks.write(repo)

        return nodenew

    except util.Abort:

        # Invalidate the previous setparents

        repo.dirstate.invalidate()

        raise

def _stabilizableunstable(repo, pctx):

    """Return a changectx for an unstable changeset which can be

    stabilized on top of pctx or one of its descendants. None if none

    can be found.

    """

    def selfanddescendants(repo, pctx):

        yield pctx

        for ctx in pctx.descendants():

            yield ctx

    # Look for an unstable which can be stabilized as a child of

    # node. The unstable must be a child of one of node predecessors.

    for ctx in selfanddescendants(repo, pctx):

        unstables = list(repo.set('unstable() and children(allprecursors(%d))',

                                  ctx.rev()))

        if unstables:

            return unstables[0]

    return None

def _bookmarksupdater(repo, oldid):

    """Return a callable update(newid) updating the current bookmark

    and bookmarks bound to oldid to newid.

    """

    bm = bookmarks.readcurrent(repo)

    def updatebookmarks(newid):

        dirty = False

        if bm:

            repo._bookmarks[bm] = newid

            dirty = True

        oldbookmarks = repo.nodebookmarks(oldid)

        if oldbookmarks:

            for b in oldbookmarks:

                repo._bookmarks[b] = newid

            dirty = True

        if dirty:

            bookmarks.write(repo)

    return updatebookmarks

### new command

#############################

cmdtable = {}

command = cmdutil.command(cmdtable)

@command('^stabilize|evolve|solve',

    [('n', 'dry-run', False, 'do not perform actions, print what to be done'),

    ('A', 'any', False, 'stabilize any unstable changeset'),

    ('c', 'continue', False, 'continue an interrupted stabilized'), ],

    _('[OPTIONS]...'))

def stabilize(ui, repo, **opts):

    """rebase an unstable changeset to make it stable again

    By default, take the first unstable changeset which could be

    rebased as child of the working directory parent revision or one

    of its descendants and rebase it.

    With --any, stabilize any unstable changeset.

    The working directory is updated to the rebased revision.

    """

    contopt = opts['continue']

    anyopt = opts['any']

    if contopt:

        if anyopt:

            raise util.Abort('can not specify both "--any" and "--continue"')

        graftcmd = commands.table['graft'][0]

        return graftcmd(ui, repo, old_obsolete=True, **{'continue': True})

    troubled = list(repo.revs('troubled()'))

    tr = _picknexttroubled(ui, repo, anyopt)

    if tr is None:

        if troubled:

            ui.write_err(_('nothing to stabilize here\n'))

            ui.status(_('(%i troubled changesets, do you want --any ?)\n')

                      % len(troubled))

            return 2

        else:

            ui.write_err(_('no troubled changeset\n'))

            return 1

    troubles = tr.troubles()

    if 'unstable' in troubles:

        return _solveunstable(ui, repo, tr, opts['dry_run'])

    elif 'latecomer' in troubles:

        return _solvelatecomer(ui, repo, tr, opts['dry_run'])

    elif 'conflicting' in troubles:

    else:

        assert False  # WHAT? unknown troubles

def _picknexttroubled(ui, repo, any=False):

    """Pick a the next trouble changeset to solve"""

    tr = _stabilizableunstable(repo, repo['.'])

    if tr is None:

        wdp = repo['.']

        if 'conflicting' in wdp.troubles():

            tr = wdp

    if tr is None and any:

        troubled = list(repo.set('unstable()'))

        if not troubled:

            troubled = list(repo.set('latecomer()'))

        if not troubled:

            troubled = list(repo.set('conflicting()'))

        if troubled:

            tr = troubled[0]

    return tr

def _solveunstable(ui, repo, orig, dryrun=False):

    """Stabilize a unstable changeset"""

    obsolete = extensions.find('obsolete')

    obs = orig.parents()[0]

    if not obs.obsolete():

        obs = orig.parents()[1]

    assert obs.obsolete()

    newer = obsolete.newerversion(repo, obs.node())

    # search of a parent which is not killed

    while newer == [()]:

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

                 " trying to stabilize on it's parent")

        obs = obs.parents()[0]

        newer = obsolete.newerversion(repo, obs.node())

    if len(newer) > 1:

        ui.write_err(_("conflict rewriting. can't choose destination\n"))

        return 2

    targets = newer[0]

    assert targets

    if len(targets) > 1:

        ui.write_err(_("does not handle splitted parent yet\n"))

        return 2

    target = targets[0]

    displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

    target = repo[target]

    repo.ui.status(_('move:'))

    if not ui.quiet:

        displayer.show(orig)

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

    if not ui.quiet:

        displayer.show(target)

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

    if dryrun:

        repo.ui.write(todo)

    else:

        repo.ui.note(todo)

        lock = repo.lock()

        try:

            relocate(repo, orig, target)

        except MergeFailure:

            repo.opener.write('graftstate', orig.hex() + '\n')

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

            repo.ui.write_err(_('fix conflict and run "hg stabilize --continue"\n'))

            raise

        finally:

            lock.release()

def _solvelatecomer(ui, repo, latecomer, dryrun=False):

    """Stabilize a latecomer changeset"""

    # For now we deny latecomer merge

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

        raise util.Abort('late comer stabilization is confused by latecomer'

                         ' %s being a merge' % latecomer)

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

    # For now we deny target merge

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

        raise util.Abort('late comer stabilization is confused by precursors'

                         ' %s being a merge' % prec)

    displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

    repo.ui.status(_('recreate:'))

    if not ui.quiet:

        displayer.show(latecomer)

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

    if not ui.quiet:

        displayer.show(prec)

    obsolete = extensions.find('obsolete')

    if dryrun:

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

        repo.ui.write(todo)

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