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

    logcmdutil,

    mdiff,

    node as nodemod,

    obsutil,

    patch,

    pycompat,

    scmutil,

    util,

)

from mercurial.utils import dateutil

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

def addtouchnoise(ui):

    obsutil.METABLACKLIST.append(re.compile(br'^__touch-noise__$'))

    obsutil.METABLACKLIST.append(re.compile(br'^divergence_source_local$'))

    obsutil.METABLACKLIST.append(re.compile(br'^divergence_source_other$'))

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

    # Use the default template unless the user provided one.

    if not opts['template']:

        opts['template'] = DEFAULT_TEMPLATE

    if opts['graph']:

        return displaygraph(ui, repo, revs, opts)

    revs.reverse()

    displayrevs(ui, repo, revs, opts)

TEMPLATE_MISSING_NODE = b"""{label("evolve.node evolve.missing_change_ctx", node|short)}"""

TEMPLATE_PRESENT_NODE = b"""{label("evolve.node", node|short)} {label("evolve.rev", "({rev})")} {label("evolve.short_description", desc|firstline)}"""

TEMPLATE_FIRST_LINE = b"""{if(rev, "%(presentnode)s", "%(missingnode)s")}""" % {

    b"presentnode": TEMPLATE_PRESENT_NODE,

    b"missingnode": TEMPLATE_MISSING_NODE

}

TEMPLATE_PREDNODES = b"""{label("evolve.node", join(prednodes % "{prednode|short}", ", "))}"""

TEMPLATE_SUCCNODES = b"""{label("evolve.node", join(succnodes % "{succnode|short}", ", "))}"""

TEMPLATE_NODES = b"""{if(prednodes, "from %(prednodes)s")}{if(succnodes, "as %(succnodes)s")}""" % {

    b"prednodes": TEMPLATE_PREDNODES,

    b"succnodes": TEMPLATE_SUCCNODES

}

TEMPLATE_REWRITE = b"""{label("evolve.verb", verb)}{if(effects, "({join(effects, ", ")})")}"""

TEMPLATE_OPERATIONS = b"""{if(operations, "using {label("evolve.operation", join(operations, ", "))}")}"""

TEMPLATE_USERS = b"""by {label("evolve.user", join(users, ", "))}"""

TEMPLATE_ONE_DATE = b"""({date(max(dates), "%a %b %d %H:%M:%S %Y %1%2")})"""

TEMPLATE_MANY_DATES = b"""(between {date(min(dates), "%a %b %d %H:%M:%S %Y %1%2")} and {date(max(dates), "%a %b %d %H:%M:%S %Y %1%2")})"""

TEMPLATE_DATES = b"""{label("evolve.date", ifeq(min(dates), max(dates), "%(onedate)s", "%(manydates)s"))}""" % {

    b"onedate": TEMPLATE_ONE_DATE,

    b"manydates": TEMPLATE_MANY_DATES

}

TEMPLATE_NOTES = b"""{if(notes, notes % "\n    note: {label("evolve.note", note)}")}"""

TEMPLATE_PATCH = b"""{if(patch, "{patch}")}{if(nopatchreason, "\n(No patch available, {nopatchreason})")}"""

DEFAULT_TEMPLATE = (b"""%(firstline)s

{markers %% "  {separate(" ", "%(rewrite)s", "%(nodes)s", "%(operations)s", "%(users)s", "%(dates)s")}%(notes)s{indent(descdiff, "    ")}{indent("%(patch)s", "    ")}\n"}

""") % {

    b"firstline": TEMPLATE_FIRST_LINE,

    b"rewrite": TEMPLATE_REWRITE,

    b"nodes": TEMPLATE_NODES,

    b"operations": TEMPLATE_OPERATIONS,

    b"users": TEMPLATE_USERS,

    b"dates": TEMPLATE_DATES,

    b"notes": TEMPLATE_NOTES,

    b"patch": TEMPLATE_PATCH,

}

def groupbyfoldid(predsets):

    """ Group nodes and related obsmarkers by fold-id metadata.

    """

    groups = {}

    for (nodes, markers) in predsets:

        grouped = False

        for marker in markers:

            metadata = dict(marker[3])

            foldid = metadata.get(b'fold-id')

            if foldid is not None:

                groups.setdefault(foldid, []).append((nodes, markers))

                grouped = True

        if not grouped:

            yield (nodes, markers)

    for foldid in sorted(groups):

        groupnodes = set()

        groupmarkers = set()

        for (nodes, markers) in groups[foldid]:

            groupnodes.update(nodes)

            groupmarkers.update(markers)

        yield (tuple(sorted(groupnodes)), tuple(sorted(groupmarkers)))

def predecessorsandmarkers(repo, node):

    """ Compute data needed for obsorigin.

    Return a generator of (nodes, markers) tuples, where nodes is a tuple of

    predecessor nodes and markers is a tuple of obsolescence markers.

    Using tuples for everything means no problems with sorted().

    """

    predecessors = repo.obsstore.predecessors

    stack = [(node, ())]

    seen = {node}

    while stack:

        node, path = stack.pop()

        for marker in sorted(predecessors.get(node, ())):

            prednode = marker[0]

            # Basic cycle protection

            if prednode in seen:

                continue

            seen.add(prednode)

            if prednode in repo:

                yield ((prednode,), path + (marker,))

            else:

                stack.append((prednode, path + (marker,)))

def _originmarkers(repo, ctx, filternonlocal):

    predecessors = repo.obsstore.predecessors

    successors = repo.obsstore.successors

    if filternonlocal:

        r = predecessorsandmarkers(repo, ctx.node())

        for (nodes, markers) in sorted(groupbyfoldid(r)):

            yield (nodes, markers)

    else:

        markers = predecessors.get(ctx.node(), ())

        data = (((marker[0],), (marker,)) for marker in markers)

        for (nodes, markers) in sorted(groupbyfoldid(data)):

            yield (nodes, markers)

    # finding prune markers

    for marker in successors.get(ctx.node(), ()):

        if not marker[1]:

            yield ((), (marker,))

    else:

class obsmarker_printer(logcmdutil.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 logcmdutil.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', {})

        # hg <= 4.6 (3fe1c9263024)

        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)

            displaynode(fm, self.repo, changenode)

            markerfm = fm.nested(b"markers")

            for nodes, markers in data:

                displaymarkers(self.ui, markerfm, nodes, markers, ctx.node(),

            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, candidates, successive=True):

    """ Check if it's possible to get a diff between node and candidates.

    `candidates` contains nodes, which can be either successors (`successive`

    is True) or predecessors (`successive` is False) of `node`.

    """

    if node not in repo:

        return False, b"context is not local"

    if len(candidates) == 0:

        if successive:

            msg = b"no successors"

        else:

            msg = b"no predecessors"

        return False, msg

    elif len(candidates) > 1:

        if successive:

            msg = b"too many successors (%d)"

        else:

            msg = b"too many predecessors (%d)"

        return False, msg % len(candidates)

    cand = candidates[0]

    if cand not in repo:

        if successive:

            msg = b"successor is unknown locally"

        else:

            msg = b"predecessor is unknown locally"

        return False, msg

    # Check that both node and cand have the same parents

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

    candp1, candp2 = repo[cand].p1(), repo[cand].p2()

    if nodep1 != candp1 or nodep2 != candp2:

        return False, b"changesets rebased"

    return True, cand

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"

    uheaders, hunks = mdiff.unidiff(basedesc, b'', succdesc, b'',

                                    basename, succname, False)

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