# coding: utf-8

# metadata.py -- code related to various metadata computation and access.

#

# Copyright 2019 Google, Inc <martinvonz@google.com>

# Copyright 2020 Pierre-Yves David <pierre-yves.david@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.

from __future__ import absolute_import, print_function

import multiprocessing

import struct

from .node import (

    nullid,

    nullrev,

)

from . import (

    error,

    pycompat,

    requirements as requirementsmod,

    util,

)

from .revlogutils import (

    flagutil as sidedataflag,

    sidedata as sidedatamod,

)

class ChangingFiles(object):

    """A class recording the changes made to files by a changeset

    Actions performed on files are gathered into 3 sets:

    - added:   files actively added in the changeset.

    - merged:  files whose history got merged

    - removed: files removed in the revision

    - salvaged: files that might have been deleted by a merge but were not

    - touched: files affected by the merge

    and copies information is held by 2 mappings

    - copied_from_p1: {"<new-name>": "<source-name-in-p1>"} mapping for copies

    - copied_from_p2: {"<new-name>": "<source-name-in-p2>"} mapping for copies

    See their inline help for details.

    """

    def __init__(

        self,

        touched=None,

        added=None,

        removed=None,

        merged=None,

        salvaged=None,

        p1_copies=None,

        p2_copies=None,

    ):

        self._added = set(() if added is None else added)

        self._merged = set(() if merged is None else merged)

        self._removed = set(() if removed is None else removed)

        self._touched = set(() if touched is None else touched)

        self._salvaged = set(() if salvaged is None else salvaged)

        self._touched.update(self._added)

        self._touched.update(self._merged)

        self._touched.update(self._removed)

        self._p1_copies = dict(() if p1_copies is None else p1_copies)

        self._p2_copies = dict(() if p2_copies is None else p2_copies)

    def __eq__(self, other):

        return (

            self.added == other.added

            and self.merged == other.merged

            and self.removed == other.removed

            and self.salvaged == other.salvaged

            and self.touched == other.touched

            and self.copied_from_p1 == other.copied_from_p1

            and self.copied_from_p2 == other.copied_from_p2

        )

    @property

    def has_copies_info(self):

        return bool(

            self.removed

            or self.merged

            or self.salvaged

            or self.copied_from_p1

            or self.copied_from_p2

        )

    @util.propertycache

    def added(self):

        """files actively added in the changeset

        Any file present in that revision that was absent in all the changeset's

        parents.

        In case of merge, this means a file absent in one of the parents but

        existing in the other will *not* be contained in this set. (They were

        added by an ancestor)

        """

        return frozenset(self._added)

    def mark_added(self, filename):

        if 'added' in vars(self):

            del self.added

        self._added.add(filename)

        self.mark_touched(filename)

    def update_added(self, filenames):

        for f in filenames:

            self.mark_added(f)

    @util.propertycache

    def merged(self):

        """files actively merged during a merge

        Any modified files which had modification on both size that needed merging.

        In this case a new filenode was created and it has two parents.

        """

        return frozenset(self._merged)

    def mark_merged(self, filename):

        if 'merged' in vars(self):

            del self.merged

        self._merged.add(filename)

        self.mark_touched(filename)

    def update_merged(self, filenames):

        for f in filenames:

            self.mark_merged(f)

    @util.propertycache

    def removed(self):

        """files actively removed by the changeset

        In case of merge this will only contain the set of files removing "new"

        content. For any file absent in the current changeset:

        a) If the file exists in both parents, it is clearly "actively" removed

        by this changeset.

        b) If a file exists in only one parent and in none of the common

        ancestors, then the file was newly added in one of the merged branches

        and then got "actively" removed.

        c) If a file exists in only one parent and at least one of the common

        ancestors using the same filenode, then the file was unchanged on one

        side and deleted on the other side. The merge "passively" propagated

        that deletion, but didn't "actively" remove the file. In this case the

        file is *not* included in the `removed` set.

        d) If a file exists in only one parent and at least one of the common

        ancestors using a different filenode, then the file was changed on one

        side and removed on the other side. The merge process "actively"

        decided to drop the new change and delete the file. Unlike in the

        previous case, (c), the file included in the `removed` set.

        Summary table for merge:

        case | exists in parents | exists in gca || removed

         (a) |       both        |     *         ||   yes

         (b) |       one         |     none      ||   yes

         (c) |       one         | same filenode ||   no

         (d) |       one         |  new filenode ||   yes

        """

        return frozenset(self._removed)

    def mark_removed(self, filename):

        if 'removed' in vars(self):

            del self.removed

        self._removed.add(filename)

        self.mark_touched(filename)

    def update_removed(self, filenames):

        for f in filenames:

            self.mark_removed(f)

    @util.propertycache

    def salvaged(self):

        """files that might have been deleted by a merge, but still exists.

        During a merge, the manifest merging might select some files for

        removal, or for a removed/changed conflict. If at commit time the file

        still exists, its removal was "reverted" and the file is "salvaged"

        """

        return frozenset(self._salvaged)

    def mark_salvaged(self, filename):

        if "salvaged" in vars(self):

            del self.salvaged

        self._salvaged.add(filename)

        self.mark_touched(filename)

    def update_salvaged(self, filenames):

        for f in filenames:

            self.mark_salvaged(f)

    @util.propertycache

    def touched(self):

        """files either actively modified, added or removed"""

        return frozenset(self._touched)

    def mark_touched(self, filename):

        if 'touched' in vars(self):

            del self.touched

        self._touched.add(filename)

    def update_touched(self, filenames):

        for f in filenames:

            self.mark_touched(f)

    @util.propertycache

    def copied_from_p1(self):

        return self._p1_copies.copy()

    def mark_copied_from_p1(self, source, dest):

        if 'copied_from_p1' in vars(self):

            del self.copied_from_p1

        self._p1_copies[dest] = source

    def update_copies_from_p1(self, copies):

        for dest, source in copies.items():

            self.mark_copied_from_p1(source, dest)

    @util.propertycache

    def copied_from_p2(self):

        return self._p2_copies.copy()

    def mark_copied_from_p2(self, source, dest):

        if 'copied_from_p2' in vars(self):

            del self.copied_from_p2

        self._p2_copies[dest] = source

    def update_copies_from_p2(self, copies):

        for dest, source in copies.items():

            self.mark_copied_from_p2(source, dest)

def compute_all_files_changes(ctx):

    """compute the files changed by a revision"""

    p1 = ctx.p1()

    p2 = ctx.p2()

    if p1.rev() == nullrev and p2.rev() == nullrev:

        return _process_root(ctx)

    elif p1.rev() != nullrev and p2.rev() == nullrev:

        return _process_linear(p1, ctx)

    elif p1.rev() == nullrev and p2.rev() != nullrev:

        # In the wild, one can encounter changeset where p1 is null but p2 is not

        return _process_linear(p1, ctx, parent=2)

    elif p1.rev() == p2.rev():

        # In the wild, one can encounter such "non-merge"

        return _process_linear(p1, ctx)

    else:

        return _process_merge(p1, p2, ctx)

def _process_root(ctx):

    """compute the appropriate changed files for a changeset with no parents"""

    # Simple, there was nothing before it, so everything is added.

    md = ChangingFiles()

    manifest = ctx.manifest()

    for filename in manifest:

        md.mark_added(filename)

    return md

def _process_linear(parent_ctx, children_ctx, parent=1):

    """compute the appropriate changed files for a changeset with a single parent"""

    md = ChangingFiles()

    parent_manifest = parent_ctx.manifest()

    children_manifest = children_ctx.manifest()

    copies_candidate = []

    for filename, d in parent_manifest.diff(children_manifest).items():

        if d[1][0] is None:

            # no filenode for the "new" value, file is absent

            md.mark_removed(filename)

        else:

            copies_candidate.append(filename)

            if d[0][0] is None:

                # not filenode for the "old" value file was absent

                md.mark_added(filename)

            else:

                # filenode for both "old" and "new"

                md.mark_touched(filename)

    if parent == 1:

        copied = md.mark_copied_from_p1

    elif parent == 2:

        copied = md.mark_copied_from_p2

    else:

        assert False, "bad parent value %d" % parent

    for filename in copies_candidate:

        copy_info = children_ctx[filename].renamed()

        if copy_info:

            source, srcnode = copy_info

            copied(source, filename)

    return md

def _process_merge(p1_ctx, p2_ctx, ctx):

    """compute the appropriate changed files for a changeset with two parents

    This is a more advance case. The information we need to record is summarise

    in the following table:

    ┌──────────────┬──────────────┬──────────────┬──────────────┬──────────────┐

    │ diff ╲  diff │       ø      │ (Some, None) │ (None, Some) │ (Some, Some) │

    │  p2   ╲  p1  │              │              │              │              │

    ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤

    │              │              │🄱  No Changes │🄳  No Changes │              │

    │  ø           │🄰  No Changes │      OR      │     OR       │🄵  No Changes │

    │              │              │🄲  Deleted[1] │🄴  Salvaged[2]│     [3]      │

    ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤

    │              │🄶  No Changes │              │              │              │

    │ (Some, None) │      OR      │🄻  Deleted    │       ø      │      ø       │

    │              │🄷  Deleted[1] │              │              │              │

    ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤

    │              │🄸  No Changes │              │              │   🄽 Touched  │

    │ (None, Some) │     OR       │      ø       │🄼   Added     │OR 🅀 Salvaged │

    │              │🄹  Salvaged[2]│              │   (copied?)  │   (copied?)  │

    ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤

    │              │              │              │   🄾 Touched  │   🄿 Merged   │

    │ (Some, Some) │🄺  No Changes │      ø       │OR 🅁 Salvaged │OR 🅂 Touched  │

    │              │     [3]      │              │   (copied?)  │   (copied?)  │

    └──────────────┴──────────────┴──────────────┴──────────────┴──────────────┘

    Special case [1]:

      The situation is:

        - parent-A:     file exists,

        - parent-B:     no file,

        - working-copy: no file.

      Detecting a "deletion" will depend on the presence of actual change on

      the "parent-A" branch:

      Subcase 🄱 or 🄶 : if the state of the file in "parent-A" is unchanged

      compared to the merge ancestors, then parent-A branch left the file

      untouched while parent-B deleted it. We simply apply the change from

      "parent-B" branch the file was automatically dropped.

      The result is:

          - file is not recorded as touched by the merge.

      Subcase 🄲 or 🄷 : otherwise, the change from parent-A branch were explicitly dropped and

      the file was "deleted again". From a user perspective, the message

      about "locally changed" while "remotely deleted" (or the other way

      around) was issued and the user chose to deleted the file.

      The result:

          - file is recorded as touched by the merge.

    Special case [2]:

      The situation is:

        - parent-A:     no file,

        - parent-B:     file,

        - working-copy: file (same content as parent-B).

      There are three subcases depending on the ancestors contents:

      - A) the file is missing in all ancestors,

      - B) at least one ancestor has the file with filenode ≠ from parent-B,

      - C) all ancestors use the same filenode as parent-B,

      Subcase (A) is the simpler, nothing happend on parent-A side while

      parent-B added it.

        The result:

            - the file is not marked as touched by the merge.

      Subcase (B) is the counter part of "Special case [1]", the file was

        modified on parent-B side, while parent-A side deleted it. However this

        time, the conflict was solved by keeping the file (and its

        modification). We consider the file as "salvaged".

        The result:

            - the file is marked as "salvaged" by the merge.

      Subcase (C) is subtle variation of the case above. In this case, the

        file in unchanged on the parent-B side and actively removed on the

        parent-A side. So the merge machinery correctly decide it should be

        removed. However, the file was explicitly restored to its parent-B

        content before the merge was commited. The file is be marked

        as salvaged too. From the merge result perspective, this is similar to

        Subcase (B), however from the merge resolution perspective they differ

        since in (C), there was some conflict not obvious solution to the

        merge (That got reversed)

    Special case [3]:

      The situation is:

        - parent-A:     file,

        - parent-B:     file (different filenode as parent-A),

        - working-copy: file (same filenode as parent-B).

      This case is in theory much simple, for this to happens, this mean the

      filenode in parent-A is purely replacing the one in parent-B (either a

      descendant, or a full new file history, see changeset). So the merge

      introduce no changes, and the file is not affected by the merge...

      However, in the wild it is possible to find commit with the above is not

      True. For example repository have some commit where the *new* node is an

      ancestor of the node in parent-A, or where parent-A and parent-B are two

      branches of the same file history, yet not merge-filenode were created

      (while the "merge" should have led to a "modification").

      Detecting such cases (and not recording the file as modified) would be a

      nice bonus. However do not any of this yet.