# logcmdutil.py - utility for log-like commands

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

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

import os

from .i18n import _

from .node import (

    nullid,

)

from . import (

    dagop,

    error,

    formatter,

    graphmod,

    match as matchmod,

    mdiff,

    patch,

    pathutil,

    pycompat,

    revset,

    revsetlang,

    scmutil,

    smartset,

    templatekw,

    templater,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

def getlimit(opts):

    """get the log limit according to option -l/--limit"""

    limit = opts.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            raise error.Abort(_('limit must be a positive integer'))

        if limit <= 0:

            raise error.Abort(_('limit must be positive'))

    else:

        limit = None

    return limit

def diffordiffstat(ui, repo, diffopts, node1, node2, match,

                   changes=None, stat=False, fp=None, prefix='',

                   root='', listsubrepos=False, hunksfilterfn=None):

    '''show diff or diffstat.'''

    if root:

        relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)

    else:

        relroot = ''

    if relroot != '':

        # XXX relative roots currently don't work if the root is within a

        # subrepo

        uirelroot = match.uipath(relroot)

        relroot += '/'

        for matchroot in match.files():

            if not matchroot.startswith(relroot):

                ui.warn(_('warning: %s not inside relative root %s\n') % (

                    match.uipath(matchroot), uirelroot))

    if stat:

        diffopts = diffopts.copy(context=0, noprefix=False)

        width = 80

        if not ui.plain():

            width = ui.termwidth()

    chunks = patch.diff(repo, node1, node2, match, changes, opts=diffopts,

                        prefix=prefix, relroot=relroot,

                        hunksfilterfn=hunksfilterfn)

    if fp is not None or ui.canwritewithoutlabels():

        out = fp or ui

        if stat:

            chunks = [patch.diffstat(util.iterlines(chunks), width=width)]

        for chunk in util.filechunkiter(util.chunkbuffer(chunks)):

            out.write(chunk)

    else:

        if stat:

            chunks = patch.diffstatui(util.iterlines(chunks), width=width)

        else:

            chunks = patch.difflabel(lambda chunks, **kwargs: chunks, chunks,

                                     opts=diffopts)

        if ui.canbatchlabeledwrites():

            def gen():

                for chunk, label in chunks:

                    yield ui.label(chunk, label=label)

            for chunk in util.filechunkiter(util.chunkbuffer(gen())):

                ui.write(chunk)

        else:

            for chunk, label in chunks:

                ui.write(chunk, label=label)

    if listsubrepos:

        ctx1 = repo[node1]

        ctx2 = repo[node2]

        for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):

            tempnode2 = node2

            try:

                if node2 is not None:

                    tempnode2 = ctx2.substate[subpath][1]

            except KeyError:

                # A subrepo that existed in node1 was deleted between node1 and

                # node2 (inclusive). Thus, ctx2's substate won't contain that

                # subpath. The best we can do is to ignore it.

                tempnode2 = None

            submatch = matchmod.subdirmatcher(subpath, match)

            sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,

                     stat=stat, fp=fp, prefix=prefix)

class changesetdiffer(object):

    """Generate diff of changeset with pre-configured filtering functions"""

    def _makefilematcher(self, ctx):

        return scmutil.matchall(ctx.repo())

    def _makehunksfilter(self, ctx):

        return None

    def showdiff(self, ui, ctx, diffopts, stat=False):

        repo = ctx.repo()

        node = ctx.node()

        prev = ctx.p1().node()

        diffordiffstat(ui, repo, diffopts, prev, node,

                       match=self._makefilematcher(ctx), stat=stat,

                       hunksfilterfn=self._makehunksfilter(ctx))

def changesetlabels(ctx):

    labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]

    if ctx.obsolete():

        labels.append('changeset.obsolete')

    if ctx.isunstable():

        labels.append('changeset.unstable')

        for instability in ctx.instabilities():

            labels.append('instability.%s' % instability)

    return ' '.join(labels)

class changesetprinter(object):

    '''show changeset information when templating not requested.'''

    def __init__(self, ui, repo, differ=None, diffopts=None, buffered=False):

        self.ui = ui

        self.repo = repo

        self.buffered = buffered

        self._differ = differ or changesetdiffer()

        self.diffopts = diffopts or {}

        self.header = {}

        self.hunk = {}

        self.lastheader = None

        self.footer = None

        self._columns = templatekw.getlogcolumns()

    def flush(self, ctx):

        rev = ctx.rev()

        if rev in self.header:

            h = self.header[rev]

            if h != self.lastheader:

                self.lastheader = h

                self.ui.write(h)

            del self.header[rev]

        if rev in self.hunk:

            self.ui.write(self.hunk[rev])

            del self.hunk[rev]

    def close(self):

        if self.footer:

            self.ui.write(self.footer)

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

        props = pycompat.byteskwargs(props)

        if self.buffered:

            self.ui.pushbuffer(labeled=True)

            self._show(ctx, copies, props)

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

        else:

            self._show(ctx, copies, props)

    def _show(self, ctx, copies, props):

        '''show a single changeset or file revision'''

        changenode = ctx.node()

        rev = ctx.rev()

        if self.ui.quiet:

            self.ui.write("%s\n" % scmutil.formatchangeid(ctx),

                          label='log.node')

            return

        columns = self._columns

        self.ui.write(columns['changeset'] % scmutil.formatchangeid(ctx),

                      label=changesetlabels(ctx))

        # branches are shown first before any other names due to backwards

        # compatibility

        branch = ctx.branch()

        # don't show the default branch name

        if branch != 'default':

            self.ui.write(columns['branch'] % branch, label='log.branch')

        for nsname, ns in self.repo.names.iteritems():

            # branches has special logic already handled above, so here we just

            # skip it

            if nsname == 'branches':

                continue

            # we will use the templatename as the color name since those two

            # should be the same

            for name in ns.names(self.repo, changenode):

                self.ui.write(ns.logfmt % name,

                              label='log.%s' % ns.colorname)

        if self.ui.debugflag:

            self.ui.write(columns['phase'] % ctx.phasestr(), label='log.phase')

        for pctx in scmutil.meaningfulparents(self.repo, ctx):

            label = 'log.parent changeset.%s' % pctx.phasestr()

            self.ui.write(columns['parent'] % scmutil.formatchangeid(pctx),

                          label=label)

        if self.ui.debugflag and rev is not None:

            mnode = ctx.manifestnode()

            mrev = self.repo.manifestlog._revlog.rev(mnode)

            self.ui.write(columns['manifest']

                          % scmutil.formatrevnode(self.ui, mrev, mnode),

                          label='ui.debug log.manifest')

        self.ui.write(columns['user'] % ctx.user(), label='log.user')

        self.ui.write(columns['date'] % dateutil.datestr(ctx.date()),

                      label='log.date')

        if ctx.isunstable():