# shelve.py - save/restore working directory state

#

# Copyright 2013 Facebook, Inc.

#

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

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

"""save and restore changes to the working directory

The "hg shelve" command saves changes made to the working directory

and reverts those changes, resetting the working directory to a clean

state.

Later on, the "hg unshelve" command restores the changes saved by "hg

shelve". Changes can be restored even after updating to a different

parent, in which case Mercurial's merge machinery will resolve any

conflicts if necessary.

You can have more than one shelved change outstanding at a time; each

shelved change has a distinct name. For details, see the help for "hg

shelve".

"""

import collections

import itertools

import stat

from .i18n import _

from .node import (

    bin,

    hex,

    nullrev,

)

from . import (

    bookmarks,

    bundle2,

    changegroup,

    cmdutil,

    discovery,

    error,

    exchange,

    hg,

    lock as lockmod,

    mdiff,

    merge,

    mergestate as mergestatemod,

    patch,

    phases,

    pycompat,

    repair,

    scmutil,

    templatefilters,

    util,

    vfs as vfsmod,

)

from .utils import (

    dateutil,

    stringutil,

)

backupdir = b'shelve-backup'

shelvedir = b'shelved'

shelvefileextensions = [b'hg', b'patch', b'shelve']

# we never need the user, so we use a

# generic user for all shelve operations

shelveuser = b'shelve@localhost'

class ShelfDir:

    def __init__(self, repo, for_backups=False):

        if for_backups:

            self.vfs = vfsmod.vfs(repo.vfs.join(backupdir))

        else:

            self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))

    def get(self, name):

        return Shelf(self.vfs, name)

    def listshelves(self):

        """return all shelves in repo as list of (time, name)"""

        try:

            names = self.vfs.listdir()

        except FileNotFoundError:

            return []

        info = []

        seen = set()

        for filename in names:

            name = filename.rsplit(b'.', 1)[0]

            if name in seen:

                continue

            seen.add(name)

            shelf = self.get(name)

            if not shelf.exists():

                continue

            mtime = shelf.mtime()

            info.append((mtime, name))

        return sorted(info, reverse=True)

class Shelf:

    """Represents a shelf, including possibly multiple files storing it.

    Old shelves will have a .patch and a .hg file. Newer shelves will

    also have a .shelve file. This class abstracts away some of the

    differences and lets you work with the shelf as a whole.

    """

    def __init__(self, vfs, name):

        self.vfs = vfs

        self.name = name

    def exists(self):

        return self.vfs.exists(self.name + b'.patch') and self.vfs.exists(

            self.name + b'.hg'

        )

    def mtime(self):

        return self.vfs.stat(self.name + b'.patch')[stat.ST_MTIME]

    def writeinfo(self, info):

        scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info)

    def hasinfo(self):

        return self.vfs.exists(self.name + b'.shelve')

    def readinfo(self):

        return scmutil.simplekeyvaluefile(

            self.vfs, self.name + b'.shelve'

        ).read()

    def writebundle(self, repo, bases, node):

        cgversion = changegroup.safeversion(repo)

        if cgversion == b'01':

            btype = b'HG10BZ'

            compression = None

        else:

            btype = b'HG20'

            compression = b'BZ'

        repo = repo.unfiltered()

        outgoing = discovery.outgoing(

            repo, missingroots=bases, ancestorsof=[node]

        )

        cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve')

        bundle_filename = self.vfs.join(self.name + b'.hg')

        bundle2.writebundle(

            repo.ui,

            cg,

            bundle_filename,

            btype,

            self.vfs,

            compression=compression,

        )

    def applybundle(self, repo, tr):

        filename = self.name + b'.hg'

        fp = self.vfs(filename)

        try:

            targetphase = phases.internal

            if not phases.supportinternal(repo):

                targetphase = phases.secret

            gen = exchange.readbundle(repo.ui, fp, filename, self.vfs)

            pretip = repo[b'tip']

            bundle2.applybundle(

                repo,

                gen,

                tr,

                source=b'unshelve',

                url=b'bundle:' + self.vfs.join(filename),

                targetphase=targetphase,

            )

            shelvectx = repo[b'tip']

            if pretip == shelvectx:

                shelverev = tr.changes[b'revduplicates'][-1]

                shelvectx = repo[shelverev]

            return shelvectx

        finally:

            fp.close()

    def open_patch(self, mode=b'rb'):

        return self.vfs(self.name + b'.patch', mode)

    def _backupfilename(self, backupvfs, filename):

        def gennames(base):

            yield base

            base, ext = base.rsplit(b'.', 1)

            for i in itertools.count(1):

                yield b'%s-%d.%s' % (base, i, ext)

        for n in gennames(filename):

            if not backupvfs.exists(n):

                return backupvfs.join(n)

    def movetobackup(self, backupvfs):

        if not backupvfs.isdir():

            backupvfs.makedir()

        for suffix in shelvefileextensions:

            filename = self.name + b'.' + suffix

            if self.vfs.exists(filename):

                util.rename(

                    self.vfs.join(filename),

                    self._backupfilename(backupvfs, filename),

                )

    def delete(self):

        for ext in shelvefileextensions:

            self.vfs.tryunlink(self.name + b'.' + ext)

class shelvedstate:

    """Handle persistence during unshelving operations.

    Handles saving and restoring a shelved state. Ensures that different

    versions of a shelved state are possible and handles them appropriately.

    """

    _version = 2

    _filename = b'shelvedstate'

    _keep = b'keep'

    _nokeep = b'nokeep'

    # colon is essential to differentiate from a real bookmark name

    _noactivebook = b':no-active-bookmark'

    _interactive = b'interactive'

    @classmethod

    def _verifyandtransform(cls, d):

        """Some basic shelvestate syntactic verification and transformation"""

        try:

            d[b'originalwctx'] = bin(d[b'originalwctx'])

            d[b'pendingctx'] = bin(d[b'pendingctx'])

            d[b'parents'] = [bin(h) for h in d[b'parents'].split(b' ')]

            d[b'nodestoremove'] = [

                bin(h) for h in d[b'nodestoremove'].split(b' ')

            ]

        except (ValueError, KeyError) as err:

            raise error.CorruptedState(stringutil.forcebytestr(err))

    @classmethod

    def _getversion(cls, repo):

        """Read version information from shelvestate file"""

        fp = repo.vfs(cls._filename)

        try:

            version = int(fp.readline().strip())

        except ValueError as err:

            raise error.CorruptedState(stringutil.forcebytestr(err))

        finally:

            fp.close()

        return version

    @classmethod

    def _readold(cls, repo):

        """Read the old position-based version of a shelvestate file"""

        # Order is important, because old shelvestate file uses it

        # to detemine values of fields (i.g. name is on the second line,

        # originalwctx is on the third and so forth). Please do not change.

        keys = [

            b'version',

            b'name',

            b'originalwctx',

            b'pendingctx',

            b'parents',

            b'nodestoremove',

            b'branchtorestore',

            b'keep',

            b'activebook',

        ]

        # this is executed only seldomly, so it is not a big deal

        # that we open this file twice

        fp = repo.vfs(cls._filename)

        d = {}

        try:

            for key in keys:

                d[key] = fp.readline().strip()

        finally:

            fp.close()

        return d

    @classmethod

    def load(cls, repo):

        version = cls._getversion(repo)

        if version < cls._version:

            d = cls._readold(repo)

        elif version == cls._version:

            d = scmutil.simplekeyvaluefile(repo.vfs, cls._filename).read(

                firstlinenonkeyval=True

            )

        else:

            raise error.Abort(

                _(

                    b'this version of shelve is incompatible '

                    b'with the version used in this repo'

                )

            )

        cls._verifyandtransform(d)

        try:

            obj = cls()

            obj.name = d[b'name']

            obj.wctx = repo[d[b'originalwctx']]

            obj.pendingctx = repo[d[b'pendingctx']]

            obj.parents = d[b'parents']

            obj.nodestoremove = d[b'nodestoremove']

            obj.branchtorestore = d.get(b'branchtorestore', b'')

            obj.keep = d.get(b'keep') == cls._keep

            obj.activebookmark = b''

            if d.get(b'activebook', b'') != cls._noactivebook:

                obj.activebookmark = d.get(b'activebook', b'')

            obj.interactive = d.get(b'interactive') == cls._interactive

        except (error.RepoLookupError, KeyError) as err:

            raise error.CorruptedState(pycompat.bytestr(err))

        return obj

    @classmethod

    def save(

        cls,

        repo,

        name,

        originalwctx,

        pendingctx,

        nodestoremove,

        branchtorestore,

        keep=False,

        activebook=b'',

        interactive=False,

    ):

        info = {

            b"name": name,

            b"originalwctx": hex(originalwctx.node()),

            b"pendingctx": hex(pendingctx.node()),

            b"parents": b' '.join([hex(p) for p in repo.dirstate.parents()]),

            b"nodestoremove": b' '.join([hex(n) for n in nodestoremove]),

            b"branchtorestore": branchtorestore,

            b"keep": cls._keep if keep else cls._nokeep,

            b"activebook": activebook or cls._noactivebook,

        }

        if interactive:

            info[b'interactive'] = cls._interactive

        scmutil.simplekeyvaluefile(repo.vfs, cls._filename).write(

            info, firstline=(b"%d" % cls._version)

        )

    @classmethod

    def clear(cls, repo):

        repo.vfs.unlinkpath(cls._filename, ignoremissing=True)

def cleanupoldbackups(repo):

    maxbackups = repo.ui.configint(b'shelve', b'maxbackups')

    backup_dir = ShelfDir(repo, for_backups=True)

    hgfiles = backup_dir.listshelves()

    if maxbackups > 0 and maxbackups < len(hgfiles):

        bordermtime = hgfiles[maxbackups - 1][0]

    else:

        bordermtime = None

    for mtime, name in hgfiles[maxbackups:]:

        if mtime == bordermtime:

            # keep it, because timestamp can't decide exact order of backups

            continue

        backup_dir.get(name).delete()

def _backupactivebookmark(repo):

    activebookmark = repo._activebookmark

    if activebookmark:

        bookmarks.deactivate(repo)

    return activebookmark

def _restoreactivebookmark(repo, mark):

    if mark:

        bookmarks.activate(repo, mark)

def _aborttransaction(repo, tr):

    """Abort current transaction for shelve/unshelve, but keep dirstate"""

    dirstatebackupname = b'dirstate.shelve'