# tags.py - read tag info from local repository

#

# Copyright 2009 Olivia Mackall <olivia@selenic.com>

# Copyright 2009 Greg Ward <greg@gerg.ca>

#

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

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

# Currently this module only deals with reading and caching tags.

# Eventually, it could take care of updating (adding/removing/moving)

# tags too.

import binascii

import io

from .node import (

    bin,

    hex,

    nullrev,

    short,

)

from .i18n import _

from .revlogutils.constants import ENTRY_NODE_ID

from . import (

    encoding,

    error,

    match as matchmod,

    scmutil,

    util,

)

from .utils import stringutil

# Tags computation can be expensive and caches exist to make it fast in

# the common case.

#

# The "hgtagsfnodes1" cache file caches the .hgtags filenode values for

# each revision in the repository. The file is effectively an array of

# fixed length records. Read the docs for "hgtagsfnodescache" for technical

# details.

#

# The .hgtags filenode cache grows in proportion to the length of the

# changelog. The file is truncated when the # changelog is stripped.

#

# The purpose of the filenode cache is to avoid the most expensive part

# of finding global tags, which is looking up the .hgtags filenode in the

# manifest for each head. This can take dozens or over 100ms for

# repositories with very large manifests. Multiplied by dozens or even

# hundreds of heads and there is a significant performance concern.

#

# There also exist a separate cache file for each repository filter.

# These "tags-*" files store information about the history of tags.

#

# The tags cache files consists of a cache validation line followed by

# a history of tags.

#

# The cache validation line has the format:

#

#   <tiprev> <tipnode> [<filteredhash>]

#

# <tiprev> is an integer revision and <tipnode> is a 40 character hex

# node for that changeset. These redundantly identify the repository

# tip from the time the cache was written. In addition, <filteredhash>,

# if present, is a 40 character hex hash of the contents of the filtered

# revisions for this filter. If the set of filtered revs changes, the

# hash will change and invalidate the cache.

#

# The history part of the tags cache consists of lines of the form:

#

#   <node> <tag>

#

# (This format is identical to that of .hgtags files.)

#

# <tag> is the tag name and <node> is the 40 character hex changeset

# the tag is associated with.

#

# Tags are written sorted by tag name.

#

# Tags associated with multiple changesets have an entry for each changeset.

# The most recent changeset (in terms of revlog ordering for the head

# setting it) for each tag is last.

def warm_cache(repo):

    """ensure the cache is properly filled"""

    unfi = repo.unfiltered()

    fnodescache = hgtagsfnodescache(unfi)

    validated_fnodes = set()

    unknown_entries = set()

    flog = None

    entries = enumerate(repo.changelog.index)

    node_revs = ((e[ENTRY_NODE_ID], rev) for (rev, e) in entries)

    for node, rev in node_revs:

        fnode = fnodescache.getfnode(node=node, rev=rev)

        if fnode != repo.nullid:

            if fnode not in validated_fnodes:

                if flog is None:

                    flog = repo.file(b'.hgtags')

                if flog.hasnode(fnode):

                    validated_fnodes.add(fnode)

                else:

                    unknown_entries.add(node)

    if unknown_entries:

        fnodescache.refresh_invalid_nodes(unknown_entries)

    fnodescache.write()

def fnoderevs(ui, repo, revs):

    """return the list of '.hgtags' fnodes used in a set revisions

    This is returned as list of unique fnodes. We use a list instead of a set

    because order matters when it comes to tags."""

    unfi = repo.unfiltered()

    tonode = unfi.changelog.node

    nodes = [tonode(r) for r in revs]

    fnodes = _getfnodes(ui, repo, nodes)

    fnodes = _filterfnodes(fnodes, nodes)

    return fnodes

def _nulltonone(repo, value):

    """convert nullid to None

    For tag value, nullid means "deleted". This small utility function helps

    translating that to None."""

    if value == repo.nullid:

        return None

    return value

def difftags(ui, repo, oldfnodes, newfnodes):

    """list differences between tags expressed in two set of file-nodes

    The list contains entries in the form: (tagname, oldvalue, new value).

    None is used to expressed missing value:

        ('foo', None, 'abcd') is a new tag,

        ('bar', 'ef01', None) is a deletion,

        ('baz', 'abcd', 'ef01') is a tag movement.

    """

    if oldfnodes == newfnodes:

        return []

    oldtags = _tagsfromfnodes(ui, repo, oldfnodes)

    newtags = _tagsfromfnodes(ui, repo, newfnodes)

    # list of (tag, old, new): None means missing

    entries = []

    for tag, (new, __) in newtags.items():

        new = _nulltonone(repo, new)

        old, __ = oldtags.pop(tag, (None, None))

        old = _nulltonone(repo, old)

        if old != new:

            entries.append((tag, old, new))

    # handle deleted tags

    for tag, (old, __) in oldtags.items():

        old = _nulltonone(repo, old)

        if old is not None:

            entries.append((tag, old, None))

    entries.sort()

    return entries

def writediff(fp, difflist):

    """write tags diff information to a file.

    Data are stored with a line based format:

        <action> <hex-node> <tag-name>\n

    Action are defined as follow:

       -R tag is removed,

       +A tag is added,

       -M tag is moved (old value),

       +M tag is moved (new value),

    Example:

         +A 875517b4806a848f942811a315a5bce30804ae85 t5

    See documentation of difftags output for details about the input.

    """

    add = b'+A %s %s\n'

    remove = b'-R %s %s\n'

    updateold = b'-M %s %s\n'

    updatenew = b'+M %s %s\n'

    for tag, old, new in difflist:

        # translate to hex

        if old is not None:

            old = hex(old)

        if new is not None:

            new = hex(new)

        # write to file

        if old is None:

            fp.write(add % (new, tag))

        elif new is None:

            fp.write(remove % (old, tag))

        else:

            fp.write(updateold % (old, tag))

            fp.write(updatenew % (new, tag))

def findglobaltags(ui, repo):

    """Find global tags in a repo: return a tagsmap

    tagsmap: tag name to (node, hist) 2-tuples.

    The tags cache is read and updated as a side-effect of calling.

    """

    (heads, tagfnode, valid, cachetags, shouldwrite) = _readtagcache(ui, repo)

    if cachetags is not None:

        assert not shouldwrite

        # XXX is this really 100% correct?  are there oddball special

        # cases where a global tag should outrank a local tag but won't,

        # because cachetags does not contain rank info?

        alltags = {}

        _updatetags(cachetags, alltags)

        return alltags

    has_node = repo.changelog.index.has_node

    for head in reversed(heads):  # oldest to newest

        assert has_node(head), b"tag cache returned bogus head %s" % short(head)

    fnodes = _filterfnodes(tagfnode, reversed(heads))

    alltags = _tagsfromfnodes(ui, repo, fnodes)

    # and update the cache (if necessary)

    if shouldwrite:

        _writetagcache(ui, repo, valid, alltags)

    return alltags

def _filterfnodes(tagfnode, nodes):

    """return a list of unique fnodes

    The order of this list matches the order of "nodes". Preserving this order

    is important as reading tags in different order provides different

    results."""

    seen = set()  # set of fnode

    fnodes = []

    for no in nodes:  # oldest to newest

        fnode = tagfnode.get(no)

        if fnode and fnode not in seen:

            seen.add(fnode)

            fnodes.append(fnode)

    return fnodes

def _tagsfromfnodes(ui, repo, fnodes):

    """return a tagsmap from a list of file-node

    tagsmap: tag name to (node, hist) 2-tuples.

    The order of the list matters."""

    alltags = {}

    fctx = None

    for fnode in fnodes:

        if fctx is None:

            fctx = repo.filectx(b'.hgtags', fileid=fnode)

        else:

            fctx = fctx.filectx(fnode)

        filetags = _readtags(ui, repo, fctx.data().splitlines(), fctx)

        _updatetags(filetags, alltags)

    return alltags

def readlocaltags(ui, repo, alltags, tagtypes):

    '''Read local tags in repo. Update alltags and tagtypes.'''

    try:

        data = repo.vfs.read(b"localtags")

    except FileNotFoundError:

        return

    # localtags is in the local encoding; re-encode to UTF-8 on

    # input for consistency with the rest of this module.

    filetags = _readtags(

        ui, repo, data.splitlines(), b"localtags", recode=encoding.fromlocal

    )

    # remove tags pointing to invalid nodes

    cl = repo.changelog

    for t in list(filetags):

        try:

            cl.rev(filetags[t][0])

        except (LookupError, ValueError):

            del filetags[t]

    _updatetags(filetags, alltags, b'local', tagtypes)

def _readtaghist(ui, repo, lines, fn, recode=None, calcnodelines=False):

    """Read tag definitions from a file (or any source of lines).

    This function returns two sortdicts with similar information:

    - the first dict, bintaghist, contains the tag information as expected by

      the _readtags function, i.e. a mapping from tag name to (node, hist):

        - node is the node id from the last line read for that name,

        - hist is the list of node ids previously associated with it (in file

          order). All node ids are binary, not hex.

    - the second dict, hextaglines, is a mapping from tag name to a list of

      [hexnode, line number] pairs, ordered from the oldest to the newest node.

    When calcnodelines is False the hextaglines dict is not calculated (an

    empty dict is returned). This is done to improve this function's

    performance in cases where the line numbers are not needed.

    """

    bintaghist = util.sortdict()

    hextaglines = util.sortdict()

    count = 0

    def dbg(msg):

        ui.debug(b"%s, line %d: %s\n" % (fn, count, msg))

    for nline, line in enumerate(lines):

        count += 1

        if not line:

            continue

        try:

            (nodehex, name) = line.split(b" ", 1)

        except ValueError:

            dbg(b"cannot parse entry")

            continue

        name = name.strip()

        if recode:

            name = recode(name)

        try:

            nodebin = bin(nodehex)

        except binascii.Error:

            dbg(b"node '%s' is not well formed" % nodehex)

            continue

        # update filetags

        if calcnodelines:

            # map tag name to a list of line numbers

            if name not in hextaglines:

                hextaglines[name] = []

            hextaglines[name].append([nodehex, nline])

            continue

        # map tag name to (node, hist)

        if name not in bintaghist:

            bintaghist[name] = []

        bintaghist[name].append(nodebin)

    return bintaghist, hextaglines

def _readtags(ui, repo, lines, fn, recode=None, calcnodelines=False):

    """Read tag definitions from a file (or any source of lines).

    Returns a mapping from tag name to (node, hist).

    "node" is the node id from the last line read for that name. "hist"

    is the list of node ids previously associated with it (in file order).

    All node ids are binary, not hex.

    """

    filetags, nodelines = _readtaghist(

        ui, repo, lines, fn, recode=recode, calcnodelines=calcnodelines

    )

    # util.sortdict().__setitem__ is much slower at replacing then inserting

    # new entries. The difference can matter if there are thousands of tags.

    # Create a new sortdict to avoid the performance penalty.

    newtags = util.sortdict()

    for tag, taghist in filetags.items():

        newtags[tag] = (taghist[-1], taghist[:-1])

    return newtags

def _updatetags(filetags, alltags, tagtype=None, tagtypes=None):

    """Incorporate the tag info read from one file into dictionnaries

    The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details).

    The second one, 'tagtypes', is optional and will be updated to track the

    "tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also

    needs to be set."""

    if tagtype is None:

        assert tagtypes is None

    for name, nodehist in filetags.items():

        if name not in alltags:

            alltags[name] = nodehist

            if tagtype is not None:

                tagtypes[name] = tagtype

            continue

        # we prefer alltags[name] if:

        #  it supersedes us OR

        #  mutual supersedes and it has a higher rank

        # otherwise we win because we're tip-most

        anode, ahist = nodehist

        bnode, bhist = alltags[name]

        if (

            bnode != anode

            and anode in bhist

            and (bnode not in ahist or len(bhist) > len(ahist))

        ):

            anode = bnode

        elif tagtype is not None: