# dirstatemap.py

#

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

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

from __future__ import absolute_import

import errno

from .i18n import _

from . import (

    error,

    pathutil,

    policy,

    pycompat,

    txnutil,

    util,

)

parsers = policy.importmod('parsers')

rustmod = policy.importrust('dirstate')

propertycache = util.propertycache

dirstatetuple = parsers.dirstatetuple

# a special value used internally for `size` if the file come from the other parent

FROM_P2 = -2

# a special value used internally for `size` if the file is modified/merged/added

NONNORMAL = -1

# a special value used internally for `time` if the time is ambigeous

AMBIGUOUS_TIME = -1

rangemask = 0x7FFFFFFF

class dirstatemap(object):

    """Map encapsulating the dirstate's contents.

    The dirstate contains the following state:

    - `identity` is the identity of the dirstate file, which can be used to

      detect when changes have occurred to the dirstate file.

    - `parents` is a pair containing the parents of the working copy. The

      parents are updated by calling `setparents`.

    - the state map maps filenames to tuples of (state, mode, size, mtime),

      where state is a single character representing 'normal', 'added',

      'removed', or 'merged'. It is read by treating the dirstate as a

      dict.  File state is updated by calling the `addfile`, `removefile` and

      `dropfile` methods.

    - `copymap` maps destination filenames to their source filename.

    The dirstate also provides the following views onto the state:

    - `nonnormalset` is a set of the filenames that have state other

      than 'normal', or are normal but have an mtime of -1 ('normallookup').

    - `otherparentset` is a set of the filenames that are marked as coming

      from the second parent when the dirstate is currently being merged.

    - `filefoldmap` is a dict mapping normalized filenames to the denormalized

      form that they appear as in the dirstate.

    - `dirfoldmap` is a dict mapping normalized directory names to the

      denormalized form that they appear as in the dirstate.

    """

    def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):

        self._ui = ui

        self._opener = opener

        self._root = root

        self._filename = b'dirstate'

        self._nodelen = 20

        self._nodeconstants = nodeconstants

        assert (

            not use_dirstate_v2

        ), "should have detected unsupported requirement"

        self._parents = None

        self._dirtyparents = False

        # for consistent view between _pl() and _read() invocations

        self._pendingmode = None

    @propertycache

    def _map(self):

        self._map = {}

        self.read()

        return self._map

    @propertycache

    def copymap(self):

        self.copymap = {}

        self._map

        return self.copymap

    def directories(self):

        # Rust / dirstate-v2 only

        return []

    def clear(self):

        self._map.clear()

        self.copymap.clear()

        self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)

        util.clearcachedproperty(self, b"_dirs")

        util.clearcachedproperty(self, b"_alldirs")

        util.clearcachedproperty(self, b"filefoldmap")

        util.clearcachedproperty(self, b"dirfoldmap")

        util.clearcachedproperty(self, b"nonnormalset")

        util.clearcachedproperty(self, b"otherparentset")

    def items(self):

        return pycompat.iteritems(self._map)

    # forward for python2,3 compat

    iteritems = items

    def __len__(self):

        return len(self._map)

    def __iter__(self):

        return iter(self._map)

    def get(self, key, default=None):

        return self._map.get(key, default)

    def __contains__(self, key):

        return key in self._map

    def __getitem__(self, key):

        return self._map[key]

    def keys(self):

        return self._map.keys()

    def preload(self):

        """Loads the underlying data, if it's not already loaded"""

        self._map

    def addfile(

        self,

        f,

        size=None,

        mtime=None,

        from_p2=False,

        possibly_dirty=False,

    ):

        """Add a tracked file to the dirstate."""

            assert not possibly_dirty

            assert not from_p2

            size = NONNORMAL

            mtime = AMBIGUOUS_TIME

        elif from_p2:

            assert not possibly_dirty

            size = FROM_P2

            mtime = AMBIGUOUS_TIME

        elif possibly_dirty:

            size = NONNORMAL

            mtime = AMBIGUOUS_TIME

        else:

            assert size != FROM_P2

            assert size != NONNORMAL

            size = size & rangemask

            mtime = mtime & rangemask

        assert size is not None

        assert mtime is not None

        old_entry = self.get(f)

        if (

            old_entry is None or old_entry.removed

        ) and "_dirs" in self.__dict__:

            self._dirs.addpath(f)

        if old_entry is None and "_alldirs" in self.__dict__:

            self._alldirs.addpath(f)

        self._map[f] = dirstatetuple(state, mode, size, mtime)

        if state != b'n' or mtime == AMBIGUOUS_TIME:

            self.nonnormalset.add(f)

        if size == FROM_P2:

            self.otherparentset.add(f)

    def removefile(self, f, in_merge=False):

        """

        Mark a file as removed in the dirstate.

        The `size` parameter is used to store sentinel values that indicate

        the file's previous state.  In the future, we should refactor this

        to be more explicit about what that state is.

        """

        entry = self.get(f)

        size = 0

        if in_merge:

            # XXX we should not be able to have 'm' state and 'FROM_P2' if not

            # during a merge. So I (marmoute) am not sure we need the

            # conditionnal at all. Adding double checking this with assert

            # would be nice.

            if entry is not None:

                # backup the previous state

                if entry.merged:  # merge

                    size = NONNORMAL

                elif entry[0] == b'n' and entry.from_p2:

                    size = FROM_P2

                    self.otherparentset.add(f)

        if size == 0:

            self.copymap.pop(f, None)

        if entry is not None and entry[0] != b'r' and "_dirs" in self.__dict__:

            self._dirs.delpath(f)

        if entry is None and "_alldirs" in self.__dict__:

            self._alldirs.addpath(f)

        if "filefoldmap" in self.__dict__:

            normed = util.normcase(f)

            self.filefoldmap.pop(normed, None)

        self._map[f] = dirstatetuple(b'r', 0, size, 0)

        self.nonnormalset.add(f)

    def dropfile(self, f, oldstate):

        """

        Remove a file from the dirstate.  Returns True if the file was

        previously recorded.

        """

        exists = self._map.pop(f, None) is not None

        if exists:

            if oldstate != b"r" and "_dirs" in self.__dict__:

                self._dirs.delpath(f)

            if "_alldirs" in self.__dict__:

                self._alldirs.delpath(f)

        if "filefoldmap" in self.__dict__:

            normed = util.normcase(f)

            self.filefoldmap.pop(normed, None)

        self.nonnormalset.discard(f)

        return exists

    def clearambiguoustimes(self, files, now):

        for f in files:

            e = self.get(f)

            if e is not None and e[0] == b'n' and e[3] == now:

                self._map[f] = dirstatetuple(e[0], e[1], e[2], AMBIGUOUS_TIME)

                self.nonnormalset.add(f)

    def nonnormalentries(self):

        '''Compute the nonnormal dirstate entries from the dmap'''

        try:

            return parsers.nonnormalotherparententries(self._map)

        except AttributeError:

            nonnorm = set()

            otherparent = set()

            for fname, e in pycompat.iteritems(self._map):

                if e[0] != b'n' or e[3] == AMBIGUOUS_TIME:

                    nonnorm.add(fname)

                if e[0] == b'n' and e[2] == FROM_P2:

                    otherparent.add(fname)

            return nonnorm, otherparent

    @propertycache

    def filefoldmap(self):

        """Returns a dictionary mapping normalized case paths to their

        non-normalized versions.

        """

        try:

            makefilefoldmap = parsers.make_file_foldmap

        except AttributeError:

            pass

        else:

            return makefilefoldmap(

                self._map, util.normcasespec, util.normcasefallback

            )

        f = {}

        normcase = util.normcase

        for name, s in pycompat.iteritems(self._map):

            if s[0] != b'r':

                f[normcase(name)] = name

        f[b'.'] = b'.'  # prevents useless util.fspath() invocation

        return f

    def hastrackeddir(self, d):

        """

        Returns True if the dirstate contains a tracked (not removed) file

        in this directory.

        """

        return d in self._dirs

    def hasdir(self, d):

        """

        Returns True if the dirstate contains a file (tracked or removed)

        in this directory.

        """

        return d in self._alldirs

    @propertycache

    def _dirs(self):

        return pathutil.dirs(self._map, b'r')

    @propertycache

    def _alldirs(self):

        return pathutil.dirs(self._map)

    def _opendirstatefile(self):

        fp, mode = txnutil.trypending(self._root, self._opener, self._filename)

        if self._pendingmode is not None and self._pendingmode != mode:

            fp.close()

            raise error.Abort(

                _(b'working directory state may be changed parallelly')

            )

        self._pendingmode = mode

        return fp

    def parents(self):

        if not self._parents:

            try:

                fp = self._opendirstatefile()

                st = fp.read(2 * self._nodelen)

                fp.close()

            except IOError as err:

                if err.errno != errno.ENOENT:

                    raise

                # File doesn't exist, so the current state is empty

                st = b''

            l = len(st)

            if l == self._nodelen * 2:

                self._parents = (

                    st[: self._nodelen],

                    st[self._nodelen : 2 * self._nodelen],

                )

            elif l == 0:

                self._parents = (

                    self._nodeconstants.nullid,

                    self._nodeconstants.nullid,

                )

            else:

                raise error.Abort(

                    _(b'working directory state appears damaged!')

                )

        return self._parents

    def setparents(self, p1, p2):

        self._parents = (p1, p2)

        self._dirtyparents = True

    def read(self):

        # ignore HG_PENDING because identity is used only for writing

        self.identity = util.filestat.frompath(

            self._opener.join(self._filename)

        )

        try:

            fp = self._opendirstatefile()

            try:

                st = fp.read()

            finally:

                fp.close()

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

            return

        if not st:

            return

        if util.safehasattr(parsers, b'dict_new_presized'):

            # Make an estimate of the number of files in the dirstate based on

            # its size. This trades wasting some memory for avoiding costly

            # resizes. Each entry have a prefix of 17 bytes followed by one or

            # two path names. Studies on various large-scale real-world repositories

            # found 54 bytes a reasonable upper limit for the average path names.

            # Copy entries are ignored for the sake of this estimate.

            self._map = parsers.dict_new_presized(len(st) // 71)

        # Python's garbage collector triggers a GC each time a certain number

        # of container objects (the number being defined by

        # gc.get_threshold()) are allocated. parse_dirstate creates a tuple

        # for each file in the dirstate. The C version then immediately marks

        # them as not to be tracked by the collector. However, this has no

        # effect on when GCs are triggered, only on what objects the GC looks