# Module dedicated to host history rewriting commands

#

# Copyright 2017 Octobus <contact@octobus.net>

#

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

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

# Status: Stabilization of the API in progress

#

#   The final set of command should go into core.

from __future__ import absolute_import

import random

from mercurial import (

    bookmarks as bookmarksmod,

    cmdutil,

    commands,

    context,

    copies,

    error,

    hg,

    lock as lockmod,

    node,

    obsolete,

    patch,

    phases,

    scmutil,

    util,

)

from mercurial.i18n import _

from . import (

    compat,

    exthelper,

    rewriteutil,

    utility,

)

eh = exthelper.exthelper()

walkopts = commands.walkopts

commitopts = commands.commitopts

commitopts2 = commands.commitopts2

mergetoolopts = commands.mergetoolopts

stringio = util.stringio

# option added by evolve

def _checknotesize(opts):

    """ make sure note is of valid format """

    note = opts.get('note')

    if not note:

        return

    if len(note) > 255:

        raise error.Abort(_("cannot store a note of more than 255 bytes"))

    if '\n' in note:

        raise error.Abort(_("note cannot contain a newline"))

def _resolveoptions(ui, opts):

    """modify commit options dict to handle related options

    For now, all it does is figure out the commit date: respect -D unless

    -d was supplied.

    """

    # N.B. this is extremely similar to setupheaderopts() in mq.py

    if not opts.get('date') and opts.get('current_date'):

        opts['date'] = '%d %d' % util.makedate()

    if not opts.get('user') and opts.get('current_user'):

        opts['user'] = ui.username()

commitopts3 = [

    ('D', 'current-date', None,

     _('record the current date as commit date')),

    ('U', 'current-user', None,

     _('record the current user as committer')),

]

interactiveopt = [['i', 'interactive', None, _('use interactive mode')]]

@eh.command(

    'amend|refresh',

    [('A', 'addremove', None,

      _('mark new/missing files as added/removed before committing')),

     ('a', 'all', False, _("match all files")),

     ('e', 'edit', False, _('invoke editor on commit messages')),

     ('', 'extract', False, _('extract changes from the commit to the working copy')),

     ('', 'close-branch', None,

      _('mark a branch as closed, hiding it from the branch list')),

     ('s', 'secret', None, _('use the secret phase for committing')),

    ] + walkopts + commitopts + commitopts2 + commitopts3 + interactiveopt,

    _('[OPTION]... [FILE]...'))

def amend(ui, repo, *pats, **opts):

    """combine a changeset with updates and replace it with a new one

    Commits a new changeset incorporating both the changes to the given files

    and all the changes from the current parent changeset into the repository.

    See :hg:`commit` for details about committing changes.

    If you don't specify -m, the parent's message will be reused.

    If --extra is specified, the behavior of `hg amend` is reversed: Changes

    to selected files in the checked out revision appear again as uncommitted

    changed in the working directory.

    Returns 0 on success, 1 if nothing changed.

    """

    opts = opts.copy()

    if opts.get('extract'):

        return uncommit(ui, repo, *pats, **opts)

    else:

        if opts.pop('all', False):

            # add an include for all

            include = list(opts.get('include'))

            include.append('re:.*')

        edit = opts.pop('edit', False)

        log = opts.get('logfile')

        opts['amend'] = True

        if not (edit or opts['message'] or log):

            opts['message'] = repo['.'].description()

        _resolveoptions(ui, opts)

        _alias, commitcmd = cmdutil.findcmd('commit', commands.table)

        try:

            wlock = repo.wlock()

            lock = repo.lock()

            rewriteutil.precheck(repo, [repo['.'].rev()], action='amend')

            return commitcmd[0](ui, repo, *pats, **opts)

        finally:

            lockmod.release(lock, wlock)

def _touchedbetween(repo, source, dest, match=None):

    touched = set()

    for files in repo.status(source, dest, match=match)[:3]:

        touched.update(files)

    return touched

def _commitfiltered(repo, ctx, match, target=None, message=None, user=None,

                    date=None):

    """Recommit ctx with changed files not in match. Return the new

    node identifier, or None if nothing changed.

    """

    base = ctx.p1()

    if target is None:

        target = base

    # ctx

    initialfiles = _touchedbetween(repo, base, ctx)

    if base == target:

        affected = set(f for f in initialfiles if match(f))

        newcontent = set()

    else:

        affected = _touchedbetween(repo, target, ctx, match=match)

        newcontent = _touchedbetween(repo, target, base, match=match)

    # The commit touchs all existing files

    # + all file that needs a new content

    # - the file affected bny uncommit with the same content than base.

    files = (initialfiles - affected) | newcontent

    if not newcontent and files == initialfiles:

        return None

    # Filter copies

    copied = copies.pathcopies(target, ctx)

    copied = dict((dst, src) for dst, src in copied.iteritems()

                  if dst in files)

    def filectxfn(repo, memctx, path, contentctx=ctx, redirect=newcontent):

        if path in redirect:

            return filectxfn(repo, memctx, path, contentctx=target, redirect=())

        if path not in contentctx:

            return None

        fctx = contentctx[path]

        flags = fctx.flags()

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

                                  islink='l' in flags,

                                  isexec='x' in flags,

                                  copied=copied.get(path))

        return mctx

    if message is None:

        message = ctx.description()

    if not user:

        user = ctx.user()

    if not date:

        date = ctx.date()

    new = context.memctx(repo,

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

                         text=message,

                         files=files,

                         filectxfn=filectxfn,

                         user=user,

                         date=date,

                         extra=ctx.extra())

    # commitctx always create a new revision, no need to check

    newid = repo.commitctx(new)

    return newid

def _uncommitdirstate(repo, oldctx, match, interactive):

    """Fix the dirstate after switching the working directory from

    oldctx to a copy of oldctx not containing changed files matched by

    match.

    """

    ctx = repo['.']

    ds = repo.dirstate

    copies = dict(ds.copies())

    if interactive:

        # In interactive cases, we will find the status between oldctx and ctx

        # and considering only the files which are changed between oldctx and

        # ctx, and the status of what changed between oldctx and ctx will help

        # us in defining the exact behavior

        m, a, r = repo.status(oldctx, ctx, match=match)[:3]

        for f in m:

            # These are files which are modified between oldctx and ctx which

            # contains two cases: 1) Were modified in oldctx and some

            # modifications are uncommitted

            # 2) Were added in oldctx but some part is uncommitted (this cannot

            # contain the case when added files are uncommitted completely as

            # that will result in status as removed not modified.)

            # Also any modifications to a removed file will result the status as

            # added, so we have only two cases. So in either of the cases, the

            # resulting status can be modified or clean.

            if ds[f] == 'r':

                # But the file is removed in the working directory, leaving that

                # as removed

                continue

            ds.normallookup(f)

        for f in a:

            # These are the files which are added between oldctx and ctx(new

            # one), which means the files which were removed in oldctx

            # but uncommitted completely while making the ctx

            # This file should be marked as removed if the working directory

            # does not adds it back. If it's adds it back, we do a normallookup.

            # The file can't be removed in working directory, because it was

            # removed in oldctx

            if ds[f] == 'a':

                ds.normallookup(f)

                continue

            ds.remove(f)

        for f in r:

            # These are files which are removed between oldctx and ctx, which

            # means the files which were added in oldctx and were completely

            # uncommitted in ctx. If a added file is partially uncommitted, that

            # would have resulted in modified status, not removed.

            # So a file added in a commit, and uncommitting that addition must

            # result in file being stated as unknown.

            if ds[f] == 'r':

                # The working directory say it's removed, so lets make the file

                # unknown

                ds.drop(f)

                continue

            ds.add(f)

    else:

        m, a, r = repo.status(oldctx.p1(), oldctx, match=match)[:3]

        for f in m:

            if ds[f] == 'r':

                # modified + removed -> removed

                continue

            ds.normallookup(f)

        for f in a:

            if ds[f] == 'r':

                # added + removed -> unknown

                ds.drop(f)

            elif ds[f] != 'a':

                ds.add(f)

        for f in r:

            if ds[f] == 'a':

                # removed + added -> normal

                ds.normallookup(f)

            elif ds[f] != 'r':

                ds.remove(f)

    # Merge old parent and old working dir copies

    oldcopies = {}

    if interactive:

        # Interactive had different meaning of the variables so restoring the

        # original meaning to use them

        m, a, r = repo.status(oldctx.p1(), oldctx, match=match)[:3]

    for f in (m + a):

        src = oldctx[f].renamed()

        if src:

            oldcopies[f] = src[0]

    oldcopies.update(copies)

    copies = dict((dst, oldcopies.get(src, src))

                  for dst, src in oldcopies.iteritems())

    # Adjust the dirstate copies

    for dst, src in copies.iteritems():

        if (src not in ctx or dst in ctx or ds[dst] != 'a'):

            src = None

        ds.copy(src, dst)

@eh.command(

    '^uncommit',

    [('a', 'all', None, _('uncommit all changes when no arguments given')),

     ('i', 'interactive', False, _('interactive mode to uncommit (EXPERIMENTAL)')),

     ('r', 'rev', '', _('revert commit content to REV instead')),

     ] + commands.walkopts + commitopts + commitopts2 + commitopts3,

    _('[OPTION]... [NAME]'))

def uncommit(ui, repo, *pats, **opts):

    """move changes from parent revision to working directory

    Changes to selected files in the checked out revision appear again as

    uncommitted changed in the working directory. A new revision

    without the selected changes is created, becomes the checked out

    revision, and obsoletes the previous one.

    The --include option specifies patterns to uncommit.

    The --exclude option specifies patterns to keep in the commit.

    The --rev argument let you change the commit file to a content of another

    revision. It still does not change the content of your file in the working

    directory.

    .. container:: verbose

       The --interactive option lets you select hunks interactively to uncommit.

       You can uncommit parts of file using this option.

    Return 0 if changed files are uncommitted.

    """

    _resolveoptions(ui, opts) # process commitopts3

    interactive = opts.get('interactive')

    wlock = lock = tr = None

    try:

        wlock = repo.wlock()

        lock = repo.lock()

        wctx = repo[None]

        if len(wctx.parents()) <= 0:

            raise error.Abort(_("cannot uncommit null changeset"))

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

            raise error.Abort(_("cannot uncommit while merging"))

        old = repo['.']

        rewriteutil.precheck(repo, [repo['.'].rev()], action='uncommit')

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

            raise error.Abort(_("cannot uncommit merge changeset"))

        oldphase = old.phase()

        rev = None

        if opts.get('rev'):

            rev = scmutil.revsingle(repo, opts.get('rev'))

            ctx = repo[None]

            if ctx.p1() == rev or ctx.p2() == rev:

                raise error.Abort(_("cannot uncommit to parent changeset"))

        onahead = old.rev() in repo.changelog.headrevs()

        disallowunstable = not obsolete.isenabled(repo,

                                                  obsolete.allowunstableopt)

        if disallowunstable and not onahead:

            raise error.Abort(_("cannot uncommit in the middle of a stack"))

        # Recommit the filtered changeset

        tr = repo.transaction('uncommit')

        updatebookmarks = rewriteutil.bookmarksupdater(repo, old.node(), tr)

        if interactive:

            opts['all'] = True

            match = scmutil.match(old, pats, opts)

            newid = _interactiveuncommit(ui, repo, old, match)

        else:

            newid = None

            includeorexclude = opts.get('include') or opts.get('exclude')

            if (pats or includeorexclude or opts.get('all')):

                match = scmutil.match(old, pats, opts)

                if not (opts['message'] or opts['logfile']):

                    opts['message'] = old.description()

                message = cmdutil.logmessage(ui, opts)

                newid = _commitfiltered(repo, old, match, target=rev,

                                        message=message, user=opts.get('user'),

                                        date=opts.get('date'))

            if newid is None:

                raise error.Abort(_('nothing to uncommit'),

                                  hint=_("use --all to uncommit all files"))

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

        phases.retractboundary(repo, tr, oldphase, [newid])