# hgweb/webutil.py - utility library for the web interface.

#

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

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

import difflib

import os

import re

from ..i18n import _

from ..node import hex, nullid, short

from .common import (

    ErrorResponse,

    HTTP_BAD_REQUEST,

    HTTP_NOT_FOUND,

    paritygen,

)

from .. import (

    context,

    error,

    match,

    mdiff,

    obsutil,

    patch,

    pathutil,

    pycompat,

    scmutil,

    templatefilters,

    templatekw,

    templateutil,

    ui as uimod,

    util,

)

from ..utils import (

    stringutil,

)

archivespecs = util.sortdict((

    ('zip', ('application/zip', 'zip', '.zip', None)),

    ('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)),

    ('bz2', ('application/x-bzip2', 'tbz2', '.tar.bz2', None)),

))

def archivelist(ui, nodeid, url=None):

    allowed = ui.configlist('web', 'allow-archive', untrusted=True)

    archives = []

    for typ, spec in archivespecs.iteritems():

        if typ in allowed or ui.configbool('web', 'allow' + typ,

                                           untrusted=True):

            archives.append({

                'type': typ,

                'extension': spec[2],

                'node': nodeid,

                'url': url,

            })

    return templateutil.mappinglist(archives)

def up(p):

    if p[0:1] != "/":

        p = "/" + p

    if p[-1:] == "/":

        p = p[:-1]

    up = os.path.dirname(p)

    if up == "/":

        return "/"

    return up + "/"

def _navseq(step, firststep=None):

    if firststep:

        yield firststep

        if firststep >= 20 and firststep <= 40:

            firststep = 50

            yield firststep

        assert step > 0

        assert firststep > 0

        while step <= firststep:

            step *= 10

    while True:

        yield 1 * step

        yield 3 * step

        step *= 10

class revnav(object):

    def __init__(self, repo):

        """Navigation generation object

        :repo: repo object we generate nav for

        """

        # used for hex generation

        self._revlog = repo.changelog

    def __nonzero__(self):

        """return True if any revision to navigate over"""

        return self._first() is not None

    __bool__ = __nonzero__

    def _first(self):

        """return the minimum non-filtered changeset or None"""

        try:

            return next(iter(self._revlog))

        except StopIteration:

            return None

    def hex(self, rev):

        return hex(self._revlog.node(rev))

    def gen(self, pos, pagelen, limit):

        """computes label and revision id for navigation link

        :pos: is the revision relative to which we generate navigation.

        :pagelen: the size of each navigation page

        :limit: how far shall we link

        The return is:

            - a single element mappinglist

            - containing a dictionary with a `before` and `after` key

            - values are dictionaries with `label` and `node` keys

        """

        if not self:

            # empty repo

            return templateutil.mappinglist([

                {'before': templateutil.mappinglist([]),

                 'after': templateutil.mappinglist([])},

            ])

        targets = []

        for f in _navseq(1, pagelen):

            if f > limit:

                break

            targets.append(pos + f)

            targets.append(pos - f)

        targets.sort()

        first = self._first()

        navbefore = [{'label': '(%i)' % first, 'node': self.hex(first)}]

        navafter = []

        for rev in targets:

            if rev not in self._revlog:

                continue

            if pos < rev < limit:

                navafter.append({'label': '+%d' % abs(rev - pos),

                                 'node': self.hex(rev)})

            if 0 < rev < pos:

                navbefore.append({'label': '-%d' % abs(rev - pos),

                                  'node': self.hex(rev)})

        navafter.append({'label': 'tip', 'node': 'tip'})

        # TODO: maybe this can be a scalar object supporting tomap()

        return templateutil.mappinglist([

            {'before': templateutil.mappinglist(navbefore),

             'after': templateutil.mappinglist(navafter)},

        ])

class filerevnav(revnav):

    def __init__(self, repo, path):

        """Navigation generation object

        :repo: repo object we generate nav for

        :path: path of the file we generate nav for

        """

        # used for iteration

        self._changelog = repo.unfiltered().changelog

        # used for hex generation

        self._revlog = repo.file(path)

    def hex(self, rev):

        return hex(self._changelog.node(self._revlog.linkrev(rev)))

# TODO: maybe this can be a wrapper class for changectx/filectx list, which

# yields {'ctx': ctx}

def _ctxsgen(context, ctxs):

    for s in ctxs:

        d = {

            'node': s.hex(),

            'rev': s.rev(),

            'user': s.user(),

            'date': s.date(),

            'description': s.description(),

            'branch': s.branch(),

        }

        if util.safehasattr(s, 'path'):

            d['file'] = s.path()

        yield d

def _siblings(siblings=None, hiderev=None):

    if siblings is None:

        siblings = []

    siblings = [s for s in siblings if s.node() != nullid]

    if len(siblings) == 1 and siblings[0].rev() == hiderev:

        siblings = []

    return templateutil.mappinggenerator(_ctxsgen, args=(siblings,))

def difffeatureopts(req, ui, section):

    diffopts = diffutil.difffeatureopts(ui, untrusted=True,

                                        section=section, whitespace=True)

    for k in ('ignorews', 'ignorewsamount', 'ignorewseol', 'ignoreblanklines'):

        v = req.qsparams.get(k)

        if v is not None:

            v = stringutil.parsebool(v)

            setattr(diffopts, k, v if v is not None else True)

    return diffopts

def annotate(req, fctx, ui):

    diffopts = difffeatureopts(req, ui, 'annotate')

    return fctx.annotate(follow=True, diffopts=diffopts)

def parents(ctx, hide=None):

    if isinstance(ctx, context.basefilectx):

        introrev = ctx.introrev()

        if ctx.changectx().rev() != introrev:

            return _siblings([ctx.repo()[introrev]], hide)

    return _siblings(ctx.parents(), hide)

def children(ctx, hide=None):

    return _siblings(ctx.children(), hide)

def renamelink(fctx):

    r = fctx.renamed()

    if r:

        return templateutil.mappinglist([{'file': r[0], 'node': hex(r[1])}])

    return templateutil.mappinglist([])

def nodetagsdict(repo, node):

    return templateutil.hybridlist(repo.nodetags(node), name='name')

def nodebookmarksdict(repo, node):

    return templateutil.hybridlist(repo.nodebookmarks(node), name='name')

def nodebranchdict(repo, ctx):

    branches = []

    branch = ctx.branch()

    # If this is an empty repo, ctx.node() == nullid,

    # ctx.branch() == 'default'.

    try:

        branchnode = repo.branchtip(branch)

    except error.RepoLookupError:

        branchnode = None

    if branchnode == ctx.node():

        branches.append(branch)

    return templateutil.hybridlist(branches, name='name')

def nodeinbranch(repo, ctx):

    branches = []

    branch = ctx.branch()

    try:

        branchnode = repo.branchtip(branch)

    except error.RepoLookupError:

        branchnode = None

    if branch != 'default' and branchnode != ctx.node():

        branches.append(branch)

    return templateutil.hybridlist(branches, name='name')

def nodebranchnodefault(ctx):

    branches = []

    branch = ctx.branch()

    if branch != 'default':

        branches.append(branch)

    return templateutil.hybridlist(branches, name='name')

def _nodenamesgen(context, f, node, name):

    for t in f(node):

        yield {name: t}

def showtag(repo, t1, node=nullid):

    args = (repo.nodetags, node, 'tag')

    return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)

def showbookmark(repo, t1, node=nullid):

    args = (repo.nodebookmarks, node, 'bookmark')

    return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)

def branchentries(repo, stripecount, limit=0):

    tips = []

    heads = repo.heads()

    parity = paritygen(stripecount)

    sortkey = lambda item: (not item[1], item[0].rev())

    def entries(context):

        count = 0

        if not tips:

            for tag, hs, tip, closed in repo.branchmap().iterbranches():

                tips.append((repo[tip], closed))

        for ctx, closed in sorted(tips, key=sortkey, reverse=True):

            if limit > 0 and count >= limit:

                return

            count += 1

            if closed:

                status = 'closed'

            elif ctx.node() not in heads:

                status = 'inactive'

            else:

                status = 'open'

            yield {

                'parity': next(parity),

                'branch': ctx.branch(),

                'status': status,

                'node': ctx.hex(),

                'date': ctx.date()

            }

    return templateutil.mappinggenerator(entries)

def cleanpath(repo, path):

    path = path.lstrip('/')

    return pathutil.canonpath(repo.root, '', path)

def changectx(repo, req):

    changeid = "tip"

    if 'node' in req.qsparams:

        changeid = req.qsparams['node']

        ipos = changeid.find(':')

        if ipos != -1:

            changeid = changeid[(ipos + 1):]

    return scmutil.revsymbol(repo, changeid)

def basechangectx(repo, req):

    if 'node' in req.qsparams:

        changeid = req.qsparams['node']

        ipos = changeid.find(':')

        if ipos != -1:

            changeid = changeid[:ipos]

            return scmutil.revsymbol(repo, changeid)

    return None

def filectx(repo, req):

    if 'file' not in req.qsparams:

        raise ErrorResponse(HTTP_NOT_FOUND, 'file not given')

    path = cleanpath(repo, req.qsparams['file'])

    if 'node' in req.qsparams:

        changeid = req.qsparams['node']

    elif 'filenode' in req.qsparams:

        changeid = req.qsparams['filenode']

    else:

        raise ErrorResponse(HTTP_NOT_FOUND, 'node or filenode not given')

    try:

        fctx = scmutil.revsymbol(repo, changeid)[path]

    except error.RepoError:

        fctx = repo.filectx(path, fileid=changeid)

    return fctx

def linerange(req):

    linerange = req.qsparams.getall('linerange')

    if not linerange:

        return None

    if len(linerange) > 1:

        raise ErrorResponse(HTTP_BAD_REQUEST,

                            'redundant linerange parameter')

    try:

        fromline, toline = map(int, linerange[0].split(':', 1))

    except ValueError:

        raise ErrorResponse(HTTP_BAD_REQUEST,