# Code dedicated to display and exploration of the obsolescence history

#

# This module content aims at being upstreamed enventually.

#

# Copyright 2017 Octobus SAS <contact@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.

import re

from mercurial import (

    commands,

    error,

    graphmod,

    patch,

    obsutil,

    node as nodemod,

    pycompat,

    scmutil,

    util,

)

from mercurial.i18n import _

from . import (

    compat,

    exthelper,

)

eh = exthelper.exthelper()

# Config

efd = {b'default': True} # pass a default value unless the config is registered

@eh.extsetup

def enableeffectflags(ui):

    item = (getattr(ui, '_knownconfig', {})

            .get(b'experimental', {})

            .get(b'evolution.effect-flags'))

    if item is not None:

        item.default = True

        efd.clear()

@eh.command(

    b'obslog|olog',

    [(b'G', b'graph', True, _(b"show the revision DAG")),

     (b'r', b'rev', [], _(b'show the specified revision or revset'), _(b'REV')),

     (b'a', b'all', False, _(b'show all related changesets, not only precursors')),

     (b'p', b'patch', False, _(b'show the patch between two obs versions')),

     (b'f', b'filternonlocal', False, _(b'filter out non local commits')),

     ] + commands.formatteropts,

    _(b'hg olog [OPTION]... [[-r] REV]...'),

    **compat.helpcategorykwargs('CATEGORY_CHANGE_NAVIGATION'))

def cmdobshistory(ui, repo, *revs, **opts):

    """show the obsolescence history of the specified revisions

    If no revision range is specified, we display the log for the current

    working copy parent.

    By default this command prints the selected revisions and all its

    precursors. For precursors pointing on existing revisions in the repository,

    it will display revisions node id, revision number and the first line of the

    description. For precursors pointing on non existing revisions in the

    repository (that can happen when exchanging obsolescence-markers), display

    only the node id.

    In both case, for each node, its obsolescence marker will be displayed with

    the obsolescence operation (rewritten or pruned) in addition of the user and

    date of the operation.

    The output is a graph by default but can deactivated with the option

    '--no-graph'.

    'o' is a changeset, '@' is a working directory parent, 'x' is obsolete,

    and '+' represents a fork where the changeset from the lines below is a

    parent of the 'o' merge on the same line.

    Paths in the DAG are represented with '|', '/' and so forth.

    Returns 0 on success.

    """

    ui.pager(b'obslog')

    revs = list(revs) + opts['rev']

    if not revs:

        revs = [b'.']

    revs = scmutil.revrange(repo, revs)

    if opts['graph']:

        return _debugobshistorygraph(ui, repo, revs, opts)

    revs.reverse()

    _debugobshistoryrevs(ui, repo, revs, opts)

def _successorsandmarkers(repo, ctx):

    """compute the raw data needed for computing obsfate

    Returns a list of dict, one dict per successors set

    """

    ssets = obsutil.successorssets(repo, ctx.node(), closest=True)

    # closestsuccessors returns an empty list for pruned revisions, remap it

    # into a list containing an empty list for future processing

    if ssets == []:

        ssets = [[]]

    # Try to recover pruned markers

    succsmap = repo.obsstore.successors

    fullsuccessorsets = [] # successor set + markers

    for sset in ssets:

        if sset:

            fullsuccessorsets.append(compat.wrap_succs(sset))

        else:

            # successorsset return an empty set() when ctx or one of its

            # successors is pruned.

            # In this case, walk the obs-markers tree again starting with ctx

            # and find the relevant pruning obs-makers, the ones without

            # successors.

            # Having these markers allow us to compute some information about

            # its fate, like who pruned this changeset and when.

            # XXX we do not catch all prune markers (eg rewritten then pruned)

            # (fix me later)

            foundany = False

            for mark in succsmap.get(ctx.node(), ()):

                if not mark[1]:

                    foundany = True

                    sset = compat._succs()

                    sset.markers.add(mark)

                    fullsuccessorsets.append(sset)

            if not foundany:

                fullsuccessorsets.append(compat._succs())

    values = []

    for sset in fullsuccessorsets:

        values.append({b'successors': sset, b'markers': sset.markers})

    return values

class obsmarker_printer(compat.changesetprinter):

    """show (available) information about a node

    We display the node, description (if available) and various information

    about obsolescence markers affecting it"""

    def __init__(self, ui, repo, *args, **kwargs):

        if kwargs.pop('obspatch', False):

            if compat.changesetdiffer is None:

                kwargs['matchfn'] = scmutil.matchall(repo)

            else:

                kwargs['differ'] = scmutil.matchall(repo)

        super(obsmarker_printer, self).__init__(ui, repo, *args, **kwargs)

        diffopts = kwargs.get('diffopts', {})

        # Compat 4.6

        if not util.safehasattr(self, "_includediff"):

            self._includediff = diffopts and diffopts.get(b'patch')

        self.template = diffopts and diffopts.get(b'template')

        self.filter = diffopts and diffopts.get(b'filternonlocal')

    def show(self, ctx, copies=None, matchfn=None, **props):

        if self.buffered:

            self.ui.pushbuffer(labeled=True)

            changenode = ctx.node()

            _props = {b"template": self.template}

            fm = self.ui.formatter(b'debugobshistory', _props)

            _debugobshistorydisplaynode(fm, self.repo, changenode)

            markerfm = fm.nested(b"markers")

            # Succs markers

            if self.filter is False:

                succs = self.repo.obsstore.successors.get(changenode, ())

                succs = sorted(succs)

                for successor in succs:

                    _debugobshistorydisplaymarker(markerfm, successor,

                                                  ctx.node(), self.repo,

                                                  self._includediff)

            else:

                r = _successorsandmarkers(self.repo, ctx)

                for succset in sorted(r):

                    markers = succset[b"markers"]

                    if not markers:

                        continue

                    successors = succset[b"successors"]

                    _debugobshistorydisplaysuccsandmarkers(markerfm, successors, markers, ctx.node(), self.repo, self._includediff)

            markerfm.end()

            fm.plain(b'\n')

            fm.end()

            self.hunk[ctx.node()] = self.ui.popbuffer()

        else:

            ### graph output is buffered only

            msg = b'cannot be used outside of the graphlog (yet)'

            raise error.ProgrammingError(msg)

    def flush(self, ctx):

        ''' changeset_printer has some logic around buffering data

        in self.headers that we don't use

        '''

        pass

def patchavailable(node, repo, successors):

    if node not in repo:

        return False, b"context is not local"

    if len(successors) == 0:

        return False, b"no successors"

    elif len(successors) > 1:

        return False, b"too many successors (%d)" % len(successors)

    succ = successors[0]

    if succ not in repo:

        return False, b"successor is unknown locally"

    # Check that both node and succ have the same parents

    nodep1, nodep2 = repo[node].p1(), repo[node].p2()

    succp1, succp2 = repo[succ].p1(), repo[succ].p2()

    if nodep1 != succp1 or nodep2 != succp2:

        return False, b"changesets rebased"

    return True, succ

def getmarkerdescriptionpatch(repo, basedesc, succdesc):

    # description are stored without final new line,

    # add one to avoid ugly diff

    basedesc += b'\n'

    succdesc += b'\n'

    # fake file name

    basename = b"changeset-description"

    succname = b"changeset-description"

    d = compat.strdiff(basedesc, succdesc, basename, succname)

    uheaders, hunks = d

    # Copied from patch.diff

    text = b''.join(sum((list(hlines) for hrange, hlines in hunks), []))

    patch = b"\n".join(uheaders + [text])

    return patch

class missingchangectx(object):

    ''' a minimal object mimicking changectx for change contexts

    references by obs markers but not available locally '''

    def __init__(self, repo, nodeid):

        self._repo = repo

        self._node = nodeid

    def node(self):

        return self._node

    def obsolete(self):

        # If we don't have it locally, it's obsolete

        return True

def cyclic(graph):

    """Return True if the directed graph has a cycle.

    The graph must be represented as a dictionary mapping vertices to

    iterables of neighbouring vertices. For example:

    >>> cyclic({1: (2,), 2: (3,), 3: (1,)})

    True

    >>> cyclic({1: (2,), 2: (3,), 3: (4,)})

    False

    Taken from: https://codereview.stackexchange.com/a/86067

    """

    visited = set()

    o = object()

    path = [o]

    path_set = set(path)

    stack = [iter(graph)]

    while stack:

        for v in sorted(stack[-1]):

            if v in path_set:

                path_set.remove(o)

                return path_set

            elif v not in visited:

                visited.add(v)

                path.append(v)

                path_set.add(v)

                stack.append(iter(graph.get(v, ())))

                break

        else:

            path_set.remove(path.pop())

            stack.pop()

    return False

def _obshistorywalker(repo, revs, walksuccessors=False, filternonlocal=False):

    """ Directly inspired by graphmod.dagwalker,

    walk the obs marker tree and yield

    (id, CHANGESET, ctx, [parentinfo]) tuples

    """

    # Get the list of nodes and links between them

    candidates, nodesucc, nodeprec = _obshistorywalker_links(repo, revs, walksuccessors)

    # Shown, set of nodes presents in items

    shown = set()

    def isvalidcandidate(candidate):

        """ Function to filter candidates, check the candidate succ are

        in shown set

        """

        return nodesucc.get(candidate, set()).issubset(shown)

    # While we have some nodes to show

    while candidates:

        # Filter out candidates, returns only nodes with all their successors

        # already shown

        validcandidates = list(filter(isvalidcandidate, candidates))

        # If we likely have a cycle

        if not validcandidates:

            cycle = cyclic(nodesucc)

            assert cycle

            # Then choose a random node from the cycle

            breaknode = sorted(cycle)[0]

            # And display it by force

            repo.ui.debug(b'obs-cycle detected, forcing display of %s\n'

                          % nodemod.short(breaknode))

            validcandidates = [breaknode]

        # Display all valid candidates

        for cand in sorted(validcandidates):

            # Remove candidate from candidates set

            candidates.remove(cand)

            # And remove it from nodesucc in case of future cycle detected

            try:

                del nodesucc[cand]

            except KeyError:

                pass

            shown.add(cand)

            # Add the right changectx class

            if cand in repo:

                changectx = repo[cand]

            else:

                if filternonlocal is False:

                    changectx = missingchangectx(repo, cand)

                else:

                    continue

            if filternonlocal is False:

                relations = nodeprec.get(cand, ())

            else:

                relations = obsutil.closestpredecessors(repo, cand)

            # print("RELATIONS", relations, list(closestpred))

            childrens = [(graphmod.PARENT, x) for x in relations]

            # print("YIELD", changectx, childrens)

            yield (cand, graphmod.CHANGESET, changectx, childrens)

def _obshistorywalker_links(repo, revs, walksuccessors=False):

    """ Iterate the obs history tree starting from revs, traversing

    each revision precursors recursively.

    If walksuccessors is True, also check that every successor has been

    walked, which ends up walking on all connected obs markers. It helps

    getting a better view with splits and divergences.

    Return a tuple of:

    - The list of node crossed

    - The dictionnary of each node successors, values are a set

    - The dictionnary of each node precursors, values are a list

    """

    precursors = repo.obsstore.predecessors

    successors = repo.obsstore.successors

    nodec = repo.changelog.node

    # Parents, set of parents nodes seen during walking the graph for node

    nodesucc = dict()

    # Childrens

    nodeprec = dict()

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