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

)

from .dirstateutils import (

    docket as docketmod,

)

parsers = policy.importmod('parsers')

rustmod = policy.importrust('dirstate')

propertycache = util.propertycache

DirstateItem = parsers.DirstateItem

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

    debug_iter = 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 _dirs_incr(self, filename, old_entry=None):

        """incremente the dirstate counter if applicable"""

        if (

            old_entry is None or old_entry.removed

        ) and "_dirs" in self.__dict__:

            self._dirs.addpath(filename)

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

            self._alldirs.addpath(filename)

    def _dirs_decr(self, filename, old_entry=None, remove_variant=False):

        """decremente the dirstate counter if applicable"""

        if old_entry is not None:

            if "_dirs" in self.__dict__ and not old_entry.removed:

                self._dirs.delpath(filename)

            if "_alldirs" in self.__dict__ and not remove_variant:

                self._alldirs.delpath(filename)

        elif remove_variant and "_alldirs" in self.__dict__:

            self._alldirs.addpath(filename)

        if "filefoldmap" in self.__dict__:

            normed = util.normcase(filename)

            self.filefoldmap.pop(normed, None)

    def set_possibly_dirty(self, filename):

        """record that the current state of the file on disk is unknown"""

        self[filename].set_possibly_dirty()

    def addfile(

        self,

        f,

        mode=0,

        size=None,

        mtime=None,

        added=False,

        merged=False,

        from_p2=False,

        possibly_dirty=False,

    ):

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

        if added:

            assert not merged

            assert not possibly_dirty

            assert not from_p2

            new_entry = DirstateItem.new_added()

        elif merged:

            assert not possibly_dirty

            assert not from_p2

            new_entry = DirstateItem.new_merged()

        elif from_p2:

            assert not possibly_dirty

            new_entry = DirstateItem.new_from_p2()

        elif possibly_dirty:

            new_entry = DirstateItem.new_possibly_dirty()

        else:

            assert size is not None

            assert mtime is not None

            size = size & rangemask

            mtime = mtime & rangemask

            new_entry = DirstateItem.new_normal(mode, size, mtime)

        old_entry = self.get(f)

        self._dirs_incr(f, old_entry)

        self._map[f] = new_entry

        if new_entry.dm_nonnormal:

            self.nonnormalset.add(f)

        else:

            self.nonnormalset.discard(f)

        if new_entry.dm_otherparent:

            self.otherparentset.add(f)

        else:

            self.otherparentset.discard(f)

    def reset_state(

        self,

        filename,

        wc_tracked,

        p1_tracked,

        p2_tracked=False,

        merged=False,

        clean_p1=False,

        clean_p2=False,

        possibly_dirty=False,

        parentfiledata=None,

    ):

        """Set a entry to a given state, diregarding all previous state

        This is to be used by the part of the dirstate API dedicated to

        adjusting the dirstate after a update/merge.

        note: calling this might result to no entry existing at all if the

        dirstate map does not see any point at having one for this file

        anymore.

        """

        if merged and (clean_p1 or clean_p2):

            msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'

            raise error.ProgrammingError(msg)

        # copy information are now outdated

        # (maybe new information should be in directly passed to this function)

        self.copymap.pop(filename, None)

        if not (p1_tracked or p2_tracked or wc_tracked):

            self.dropfile(filename)

            return

        elif merged:

            # XXX might be merged and removed ?

            entry = self.get(filename)

            if entry is None or not entry.tracked:

                # XXX mostly replicate dirstate.other parent.  We should get

                # the higher layer to pass us more reliable data where `merged`

                # actually mean merged. Dropping this clause will show failure

                # in `test-graft.t`

                merged = False

                clean_p2 = True

        elif not (p1_tracked or p2_tracked) and wc_tracked:

            pass  # file is added, nothing special to adjust

        elif (p1_tracked or p2_tracked) and not wc_tracked:

            pass

        elif clean_p2 and wc_tracked:

            if p1_tracked or self.get(filename) is not None:

                # XXX the `self.get` call is catching some case in

                # `test-merge-remove.t` where the file is tracked in p1, the

                # p1_tracked argument is False.

                #

                # In addition, this seems to be a case where the file is marked

                # as merged without actually being the result of a merge

                # action. So thing are not ideal here.

                merged = True

                clean_p2 = False

        elif not p1_tracked and p2_tracked and wc_tracked:

            clean_p2 = True

        elif possibly_dirty:

            pass

        elif wc_tracked:

            # this is a "normal" file

            if parentfiledata is None:

                msg = b'failed to pass parentfiledata for a normal file: %s'

                msg %= filename

                raise error.ProgrammingError(msg)

        else:

            assert False, 'unreachable'

        old_entry = self._map.get(filename)

        self._dirs_incr(filename, old_entry)

        entry = DirstateItem(

            wc_tracked=wc_tracked,

            p1_tracked=p1_tracked,

            p2_tracked=p2_tracked,

            merged=merged,

            clean_p1=clean_p1,

            clean_p2=clean_p2,

            possibly_dirty=possibly_dirty,

            parentfiledata=parentfiledata,

        )

        if entry.dm_nonnormal:

            self.nonnormalset.add(filename)

        else:

            self.nonnormalset.discard(filename)

        if entry.dm_otherparent:

            self.otherparentset.add(filename)

        else:

            self.otherparentset.discard(filename)

        self._map[filename] = entry

    def set_untracked(self, f):

        """Mark a file as no longer tracked in the dirstate map"""

        entry = self.get(f)

        if entry is None:

            return False

        else:

            self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)

            if not entry.merged:

                self.copymap.pop(f, None)

            if entry.added:

                self.nonnormalset.discard(f)

                self._map.pop(f, None)

            else:

                self.nonnormalset.add(f)

                if entry.from_p2:

                    self.otherparentset.add(f)

                entry.set_untracked()

            return True

    def dropfile(self, f):

        """

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

        previously recorded.

        """

        old_entry = self._map.pop(f, None)

        self._dirs_decr(f, old_entry=old_entry)

        self.nonnormalset.discard(f)

        self.copymap.pop(f, None)

        return old_entry is not None

    def clearambiguoustimes(self, files, now):

        for f in files:

            e = self.get(f)

            if e is not None and e.need_delay(now):

                e.set_possibly_dirty()

                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.dm_nonnormal:

                    nonnorm.add(fname)

                if e.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 not s.removed:

                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):

        """