#

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

import os

import re

from ..i18n import _

from ..node import hex, short

from .common import (

    ErrorResponse,

    HTTP_FORBIDDEN,

    HTTP_NOT_FOUND,

    get_contact,

    paritygen,

    staticfile,

)

from .. import (

    archival,

    dagop,

    encoding,

    error,

    graphmod,

    pycompat,

    revset,

    revsetlang,

    scmutil,

    smartset,

    templater,

    templateutil,

)

__all__ = []

commands = {}

class webcommand(object):

    """Decorator used to register a web command handler.

    The decorator takes as its positional arguments the name/path the

    command should be accessible under.

    When called, functions receive as arguments a ``requestcontext``,

    ``wsgirequest``, and a templater instance for generatoring output.

    The functions should populate the ``rctx.res`` object with details

    about the HTTP response.

    The function returns a generator to be consumed by the WSGI application.

    For most commands, this should be the result from

    ``web.res.sendresponse()``. Many commands will call ``web.sendtemplate()``

    to render a template.

    Usage:

    @webcommand('mycommand')

    def mycommand(web):

        pass

    """

    def __init__(self, name):

        self.name = name

    def __call__(self, func):

        __all__.append(self.name)

        commands[self.name] = func

        return func

@webcommand('log')

def log(web):

    """

    /log[/{revision}[/{path}]]

    --------------------------

    Show repository or file history.

    For URLs of the form ``/log/{revision}``, a list of changesets starting at

    the specified changeset identifier is shown. If ``{revision}`` is not

    defined, the default is ``tip``. This form is equivalent to the

    ``changelog`` handler.

    For URLs of the form ``/log/{revision}/{file}``, the history for a specific

    file will be shown. This form is equivalent to the ``filelog`` handler.

    """

    if web.req.qsparams.get('file'):

        return filelog(web)

    else:

        return changelog(web)

@webcommand('rawfile')

def rawfile(web):

    guessmime = web.configbool('web', 'guessmime')

    path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', ''))

    if not path:

        return manifest(web)

    try:

        fctx = webutil.filectx(web.repo, web.req)

    except error.LookupError as inst:

        try:

            return manifest(web)

        except ErrorResponse:

            raise inst

    path = fctx.path()

    text = fctx.data()

    mt = 'application/binary'

    if guessmime:

        mt = mimetypes.guess_type(pycompat.fsdecode(path))[0]

        if mt is None:

            if stringutil.binary(text):

                mt = 'application/binary'

            else:

                mt = 'text/plain'

        else:

            mt = pycompat.sysbytes(mt)

    if mt.startswith('text/'):

        mt += '; charset="%s"' % encoding.encoding

    web.res.headers['Content-Type'] = mt

    web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename

    web.res.setbodybytes(text)

    return web.res.sendresponse()

def _filerevision(web, fctx):

    f = fctx.path()

    text = fctx.data()

    parity = paritygen(web.stripecount)

    ishead = fctx.filenode() in fctx.filelog().heads()

    if stringutil.binary(text):

        mt = pycompat.sysbytes(

            mimetypes.guess_type(pycompat.fsdecode(f))[0]

        text = '(binary:%s)' % mt

    def lines(context):

        for lineno, t in enumerate(text.splitlines(True)):

    return web.sendtemplate(

        'filerevision',

        file=f,

        path=webutil.up(f),

        text=templateutil.mappinggenerator(lines),

        symrev=webutil.symrevorshortnode(web.req, fctx),

        rename=webutil.renamelink(fctx),

        permissions=fctx.manifest().flags(f),

        ishead=int(ishead),

@webcommand('file')

def file(web):

    """

    /file/{revision}[/{path}]

    -------------------------

    Show information about a directory or file in the repository.

    Info about the ``path`` given as a URL parameter will be rendered.

    If ``path`` is a directory, information about the entries in that

    directory will be rendered. This form is equivalent to the ``manifest``

    handler.

    If ``path`` is a file, information about that file will be shown via

    the ``filerevision`` template.

    If ``path`` is not defined, information about the root directory will

    be rendered.

    """

    if web.req.qsparams.get('style') == 'raw':

        return rawfile(web)

    path = webutil.cleanpath(web.repo, web.req.qsparams.get('file', ''))

    if not path:

        return manifest(web)

    try:

        return _filerevision(web, webutil.filectx(web.repo, web.req))

    except error.LookupError as inst:

        try:

            return manifest(web)

        except ErrorResponse:

            raise inst

def _search(web):

    MODE_REVISION = 'rev'

    MODE_KEYWORD = 'keyword'

    MODE_REVSET = 'revset'

    def revsearch(ctx):

        yield ctx

    def keywordsearch(query):

        lower = encoding.lower

        qw = lower(query).split()

        def revgen():

            cl = web.repo.changelog

            for i in pycompat.xrange(len(web.repo) - 1, 0, -100):

                l = []

                for j in cl.revs(max(0, i - 99), i):

                    ctx = web.repo[j]

                    l.append(ctx)

                l.reverse()

                for e in l:

                    yield e

        for ctx in revgen():

            miss = 0

            for q in qw:

                    miss = 1

                    break

            if miss:

                continue

            yield ctx

    def revsetsearch(revs):

        for r in revs:

            yield web.repo[r]

    searchfuncs = {

        MODE_REVISION: (revsearch, 'exact revision search'),

        MODE_KEYWORD: (keywordsearch, 'literal keyword search'),

        MODE_REVSET: (revsetsearch, 'revset expression search'),

    }

    def getsearchmode(query):

        try:

            ctx = scmutil.revsymbol(web.repo, query)

        except (error.RepoError, error.LookupError):

            # query is not an exact revision pointer, need to

            # decide if it's a revset expression or keywords

            pass

        else:

            return MODE_REVISION, ctx

        revdef = 'reverse(%s)' % query

        try:

            tree = revsetlang.parse(revdef)

        except error.ParseError:

            # can't parse to a revset tree

            return MODE_KEYWORD, query

        if revsetlang.depth(tree) <= 2:

            # no revset syntax used

            return MODE_KEYWORD, query

            return MODE_KEYWORD, query

        funcsused = revsetlang.funcsused(tree)

        if not funcsused.issubset(revset.safesymbols):

            return MODE_KEYWORD, query

        try:

            revs = mfunc(web.repo)

            return MODE_REVSET, revs

            # ParseError: wrongly placed tokens, wrongs arguments, etc

            # RepoLookupError: no such revision, e.g. in 'revision:'

            # Abort: bookmark/tag not exists

            # LookupError: ambiguous identifier, e.g. in '(bc)' on a large repo

            return MODE_KEYWORD, query

    def changelist(context):

        count = 0

        for ctx in searchfunc[0](funcarg):

            count += 1

            n = scmutil.binnode(ctx)

            showtags = webutil.showtag(web.repo, 'changelogtag', n)

            files = webutil.listfilediffs(ctx.files(), n, web.maxfiles)

            lm = webutil.commonentry(web.repo, ctx)

            yield lm

            if count >= revcount:

                break

    query = web.req.qsparams['rev']

    revcount = web.maxchanges

    if 'revcount' in web.req.qsparams:

        try:

            revcount = int(web.req.qsparams.get('revcount', revcount))

            revcount = max(revcount, 1)

            web.tmpl.defaults['sessionvars']['revcount'] = revcount

        except ValueError:

            pass

    lessvars = copy.copy(web.tmpl.defaults['sessionvars'])

    lessvars['revcount'] = max(revcount // 2, 1)

    lessvars['rev'] = query

    morevars = copy.copy(web.tmpl.defaults['sessionvars'])

    morevars['revcount'] = revcount * 2

    morevars['rev'] = query

    mode, funcarg = getsearchmode(query)

    if 'forcekw' in web.req.qsparams:

        showforcekw = ''

        showunforcekw = searchfuncs[mode][1]

        mode = MODE_KEYWORD

        funcarg = query

    else:

        if mode != MODE_KEYWORD:

            showforcekw = searchfuncs[MODE_KEYWORD][1]

        else:

            showforcekw = ''

        showunforcekw = ''

    searchfunc = searchfuncs[mode]

    tip = web.repo['tip']

    parity = paritygen(web.stripecount)

    return web.sendtemplate(

        'search',

        query=query,

        node=tip.hex(),

        symrev='tip',

        entries=templateutil.mappinggenerator(changelist, name='searchentry'),

        archives=web.archivelist('tip'),

        morevars=morevars,

        lessvars=lessvars,

        modedesc=searchfunc[1],

        showforcekw=showforcekw,

@webcommand('changelog')

def changelog(web, shortlog=False):

    """

    /changelog[/{revision}]

    -----------------------

    Show information about multiple changesets.

    If the optional ``revision`` URL argument is absent, information about

    all changesets starting at ``tip`` will be rendered. If the ``revision``

    argument is present, changesets will be shown starting from the specified

    revision.

    If ``revision`` is absent, the ``rev`` query string argument may be

    defined. This will perform a search for changesets.

    The argument for ``rev`` can be a single revision, a revision set,

    or a literal keyword to search for in changeset data (equivalent to

    :hg:`log -k`).

    The ``revcount`` query string argument defines the maximum numbers of

    changesets to render.

    For non-searches, the ``changelog`` template will be rendered.

    """

    query = ''

    if 'node' in web.req.qsparams:

        ctx = webutil.changectx(web.repo, web.req)

        symrev = webutil.symrevorshortnode(web.req, ctx)

    elif 'rev' in web.req.qsparams:

        return _search(web)

    else:

        ctx = web.repo['tip']

        symrev = 'tip'

    def changelist(maxcount):

        revs = []

        if pos != -1:

            revs = web.repo.changelog.revs(pos, 0)

        for entry in webutil.changelistentries(web, revs, maxcount, parity):

            yield entry

    if shortlog:

        revcount = web.maxshortchanges

    else:

        revcount = web.maxchanges

    if 'revcount' in web.req.qsparams:

        try:

            revcount = int(web.req.qsparams.get('revcount', revcount))

            revcount = max(revcount, 1)

            web.tmpl.defaults['sessionvars']['revcount'] = revcount

        except ValueError:

            pass

    lessvars = copy.copy(web.tmpl.defaults['sessionvars'])

    lessvars['revcount'] = max(revcount // 2, 1)

    morevars = copy.copy(web.tmpl.defaults['sessionvars'])

    morevars['revcount'] = revcount * 2

    count = len(web.repo)

    pos = ctx.rev()

    parity = paritygen(web.stripecount)

    changenav = webutil.revnav(web.repo).gen(pos, revcount, count)

    entries = list(changelist(revcount + 1))

    latestentry = entries[:1]

    if len(entries) > revcount:

        nextentry = entries[-1:]

        entries = entries[:-1]

    else:

        nextentry = []

    return web.sendtemplate(

        'shortlog' if shortlog else 'changelog',

        changenav=changenav,

        node=ctx.hex(),

        rev=pos,

        symrev=symrev,

        changesets=count,

        entries=templateutil.mappinglist(entries),

        latestentry=templateutil.mappinglist(latestentry),

        nextentry=templateutil.mappinglist(nextentry),

        archives=web.archivelist('tip'),

        revcount=revcount,

        morevars=morevars,

        lessvars=lessvars,

@webcommand('shortlog')