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

    logcmdutil,

    merge,

    node,

    obsolete,

    patch,

    phases,

    pycompat,

    scmutil,

    util,

)

from mercurial.utils import dateutil

from mercurial.i18n import _

from . import (

    compat,

    state,

    exthelper,

    rewriteutil,

    utility,

)

eh = exthelper.exthelper()

walkopts = commands.walkopts

commitopts = commands.commitopts

commitopts2 = commands.commitopts2

mergetoolopts = commands.mergetoolopts

stringio = util.stringio

precheck_contentdiv = rewriteutil.precheck_contentdiv

# option added by evolve

def _checknotesize(ui, opts):

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

    note = opts.get('note')

    if not note:

        return

    if len(note) > 255:

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

    if b'\n' in note:

        raise error.Abort(_(b"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'] = b'%d %d' % dateutil.makedate()

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

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

commitopts3 = [

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

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

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

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

]

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

@eh.command(

    b'amend|refresh',

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

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

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

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

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

     (b'', b'patch', False, _(b'make changes to wdir parent by editing patch')),

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

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

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

     (b'n', b'note', b'', _(b'store a note on amend'), _(b'TEXT')),

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

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

    helpbasic=True,

    **compat.helpcategorykwargs('CATEGORY_COMMITTING'))

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 --extract 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.

    """

    _checknotesize(ui, opts)

    opts = opts.copy()

    if opts.get('patch') and opts.get('extract'):

        raise error.Abort(_(b'cannot use both --patch and --extract'))

    if opts.get('patch'):

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

    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(b're:.*')

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

        log = opts.get('logfile')

        opts['amend'] = True

        _resolveoptions(ui, opts)

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

        with repo.wlock(), repo.lock():

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

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

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

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

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

    """logic for --patch flag of `hg amend` command."""

    with repo.wlock(), repo.lock(), repo.transaction(b'amend') as tr:

        cmdutil.bailifchanged(repo)

        # first get the patch

        old = repo[b'.']

        p1 = old.p1()

        rewriteutil.precheck(repo, [old.rev()], b'amend')

        diffopts = patch.difffeatureopts(repo.ui, whitespace=True)

        diffopts.nodates = True

        diffopts.git = True

        fp = stringio()

        _writectxmetadata(repo, old, fp)

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

        for chunk, label in patch.diffui(repo, p1.node(), old.node(),

                                         match=matcher,

                                         opts=diffopts):

            fp.write(chunk)

        newnode = _editandapply(ui, repo, pats, old, p1, fp, diffopts)

        if newnode == old.node():

            raise error.Abort(_(b"nothing changed"))

        metadata = {}

        if opts.get('note'):

            metadata[b'note'] = opts['note']

        replacements = {old.node(): [newnode]}

        scmutil.cleanupnodes(repo, replacements, operation=b'amend',

                             metadata=metadata)

        phases.retractboundary(repo, tr, old.phase(), [newnode])

        hg.updaterepo(repo, newnode, True)

def _editandapply(ui, repo, pats, old, p1, fp, diffopts):

    newnode = None

    while newnode is None:

        fp.seek(0)

        previous_patch = fp.getvalue()

        newpatch = ui.edit(fp.getvalue(), old.user(), action=b"diff")

        afp = stringio()

        afp.write(newpatch)

        if pats:

            # write rest of the files in the patch

            restmatcher = scmutil.match(old, [], opts={b'exclude': pats})

            for chunk, label in patch.diffui(repo, p1.node(), old.node(),

                                             match=restmatcher,

                                             opts=diffopts):

                afp.write(chunk)

        user_patch = afp.getvalue()

        if not user_patch:

            raise error.Abort(_(b"empty patch file, amend aborted"))

        if user_patch == previous_patch:

            raise error.Abort(_(b"patch unchanged"))

        afp.seek(0)

        # write the patch to repo and get the newnode

        try:

            newnode = _writepatch(ui, repo, old, afp)

        except patch.PatchError as err:

            ui.write_err(_(b"failed to apply edited patch: %s\n") % err)

            defaultchoice = 0 # yes

            if not ui.interactive:

                defaultchoice = 1 # no

            retrychoice = _(b'try to fix the patch (yn)?$$ &Yes $$ &No')

            if ui.promptchoice(retrychoice, default=defaultchoice):

                raise error.Abort(_(b"Could not apply amended path"))

            else:

                # consider a third choice where we restore the original patch

                fp = stringio()

                fp.write(user_patch)

    return newnode

def _writepatch(ui, repo, old, fp):

    """utility function to use filestore and patchrepo to apply a patch to the

    repository with metadata being extracted from the patch"""

    patchcontext = patch.extract(ui, fp)

    pold = old.p1()

    with patchcontext as metadata:

        # store the metadata from the patch to variables

        parents = (metadata.get(b'p1'), metadata.get(b'p2'))

        date = metadata.get(b'date') or old.date()

        branch = metadata.get(b'branch') or old.branch()

        user = metadata.get(b'user') or old.user()

        # XXX: we must extract extras from the patchfile too

        extra = old.extra()

        message = metadata.get(b'message') or old.description()

        store = patch.filestore()

        fp.seek(0)

        try:

            files = set()

            # beware: next line may raise a PatchError to be handled by the caller

            # of this function

            patch.patchrepo(ui, repo, pold, store, fp, 1, b'',

                            files=files, eolmode=None)

            memctx = context.memctx(repo, parents, message, files=files,

                                    filectxfn=store,

                                    user=user,

                                    date=date,

                                    branch=branch,

                                    extra=extra)

            newcm = memctx.commit()

        finally:

            store.close()

    return newcm

def _writectxmetadata(repo, ctx, fp):

    nodeval = scmutil.binnode(ctx)

    parents = [p.node() for p in ctx.parents() if p]

    branch = ctx.branch()

    if parents:

        prev = parents[0]

    else:

        prev = node.nullid

    fp.write(b"# HG changeset patch\n")

    fp.write(b"# User %s\n" % ctx.user())

    fp.write(b"# Date %d %d\n" % ctx.date())

    fp.write(b"#      %s\n" % dateutil.datestr(ctx.date()))

    if branch and branch != b'default':

        fp.write(b"# Branch %s\n" % branch)

    fp.write(b"# Node ID %s\n" % node.hex(nodeval))

    fp.write(b"# Parent  %s\n" % node.hex(prev))

    if len(parents) > 1:

        fp.write(b"# Parent  %s\n" % node.hex(parents[1]))

    for headerid in cmdutil.extraexport:

        header = cmdutil.extraexportmap[headerid](1, ctx)

        if header is not None:

            fp.write(b'# %s\n' % header)

    fp.write(ctx.description().rstrip())

    fp.write(b"\n\n")

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

    touched = set()

    st = repo.status(source, dest, match=match)

    touched.update(st.modified)

    touched.update(st.added)

    touched.update(st.removed)

    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.items()

                  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 = compat.memfilectx(repo, memctx, fctx, flags, copied, 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[b'.']

    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

        st = repo.status(oldctx, ctx, match=match)

        for f in st.modified:

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