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

#

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

# Copyright 2005-2007 Olivia Mackall <olivia@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 ..pycompat import setattr

from .common import (

    ErrorResponse,

    HTTP_BAD_REQUEST,

    HTTP_NOT_FOUND,

    paritygen,

)

from .. import (

    context,

    diffutil,

    error,

    match,

    mdiff,

    obsutil,

    patch,

    pathutil,

    pycompat,

    scmutil,

    templatefilters,

    templatekw,

    templateutil,

    ui as uimod,

    util,

)

from ..utils import stringutil

archivespecs = util.sortdict(

    (

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

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

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

    )

)

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

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

    archives = []

    for typ, spec in pycompat.iteritems(archivespecs):

        if typ in allowed or ui.configbool(

            b'web', b'allow' + typ, untrusted=True

        ):

            archives.append(

                {

                    b'type': typ,

                    b'extension': spec[2],

                    b'node': nodeid,

                    b'url': url,

                }

            )

    return templateutil.mappinglist(archives)

def up(p):

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

        p = b"/" + p

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

        p = p[:-1]

    up = os.path.dirname(p)

    if up == b"/":

        return b"/"

    return up + b"/"

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(

                [

                    {

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

                        b'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 = [{b'label': b'(%i)' % first, b'node': self.hex(first)}]

        navafter = []

        for rev in targets:

            if rev not in self._revlog:

                continue

            if pos < rev < limit:

                navafter.append(

                    {b'label': b'+%d' % abs(rev - pos), b'node': self.hex(rev)}

                )

            if 0 < rev < pos:

                navbefore.append(

                    {b'label': b'-%d' % abs(rev - pos), b'node': self.hex(rev)}

                )

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

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

        return templateutil.mappinglist(

            [

                {

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

                    b'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 = {

            b'node': s.hex(),

            b'rev': s.rev(),

            b'user': s.user(),

            b'date': s.date(),

            b'description': s.description(),

            b'branch': s.branch(),

        }

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

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

        yield d

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

    if siblings is None:

        siblings = []

    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 (

        b'ignorews',

        b'ignorewsamount',

        b'ignorewseol',

        b'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, b'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([{b'file': r[0], b'node': hex(r[1])}])

    return templateutil.mappinglist([])

def nodetagsdict(repo, node):

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

def nodebookmarksdict(repo, node):

    return templateutil.hybridlist(repo.nodebookmarks(node), name=b'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=b'name')

def nodeinbranch(repo, ctx):

    branches = []

    branch = ctx.branch()

    try:

        branchnode = repo.branchtip(branch)

    except error.RepoLookupError:

        branchnode = None

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

        branches.append(branch)

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

def nodebranchnodefault(ctx):

    branches = []

    branch = ctx.branch()

    if branch != b'default':

        branches.append(branch)

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

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

    for t in f(node):

        yield {name: t}

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

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

    args = (repo.nodebookmarks, node, b'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 = b'closed'

            elif ctx.node() not in heads:

                status = b'inactive'

            else:

                status = b'open'

            yield {

                b'parity': next(parity),

                b'branch': ctx.branch(),

                b'status': status,

                b'node': ctx.hex(),

                b'date': ctx.date(),

            }

    return templateutil.mappinggenerator(entries)

def cleanpath(repo, path):

    path = path.lstrip(b'/')

    auditor = pathutil.pathauditor(repo.root, realfs=False)

    return pathutil.canonpath(repo.root, b'', path, auditor=auditor)

def changectx(repo, req):

    changeid = b"tip"

    if b'node' in req.qsparams:

        changeid = req.qsparams[b'node']

        ipos = changeid.find(b':')