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

    merge,

    node,

    obsolete,

    patch,

    phases,

    scmutil,

    util,

)

from mercurial.i18n import _

from mercurial.utils import dateutil

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

# option added by evolve

def _checknotesize(ui, opts):

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

    note = opts.get('note')

    if not note:

        return

    if not compat.isobsnotesupported():

        ui.warn(_("current hg version does not support storing"

                  " note in obsmarker\n"))

    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' % compat.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')),

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

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

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

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

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

    ] + 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 --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'):

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

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

        log = opts.get('logfile')

        opts['amend'] = True

        _resolveoptions(ui, opts)

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

        try:

            wlock = repo.wlock()

            lock = repo.lock()

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

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

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

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

        finally:

            lockmod.release(lock, wlock)

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

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

    lock = wlock = tr = None

    try:

        wlock = repo.wlock()

        lock = repo.lock()

        tr = repo.transaction('amend')

        cmdutil.bailifchanged(repo)

        # first get the patch

        old = repo['.']

        p1 = old.p1()

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

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

        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(_("nothing changed"))

        metadata = {}

        if opts.get('note'):

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

        compat.createmarkers(repo, [(old, (repo[newnode],))],

                             metadata=metadata, operation='amend')

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

        hg.updaterepo(repo, newnode, True)

        bookmarkupdater(newnode)

        tr.close()

    finally:

        tr.release()

        lockmod.release(lock, wlock)

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

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

    newnode = None

    while newnode is None:

        fp.seek(0)

        previous_patch = fp.getvalue()

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

        afp = stringio()

        afp.write(newpatch)

        if pats:

            # write rest of the files in the patch

            restmatcher = scmutil.match(old, [], opts={'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 user_patch == previous_patch:

            raise error.Abort(_("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(_("failed to apply edited patch: %s\n") % err)

            defaultchoice = 0 # yes

            if not ui.interactive:

                defaultchoice = 1 # no

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

                raise error.Abort(_("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"""

    metadata = patch.extract(ui, fp)

    pold = old.p1()

    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("# HG changeset patch\n")

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

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

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

    if branch and branch != 'default':

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

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

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

    if len(parents) > 1:

        fp.write("# 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('# %s\n' % header)

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

    fp.write("\n\n")

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 = 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['.']

    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