#

# 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 ..pycompat import getattr

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,

    templateutil,

)

from ..utils import stringutil

from . import webutil

__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(b'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(b'file'):

        return filelog(web)

    else:

        return changelog(web)

@webcommand(b'rawfile')

def rawfile(web):

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

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

    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 = b'application/binary'

    if guessmime:

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

        if mt is None:

            if stringutil.binary(text):

                mt = b'application/binary'

            else:

                mt = b'text/plain'

        else:

            mt = pycompat.sysbytes(mt)

    if mt.startswith(b'text/'):

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

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

    filename = (

        path.rpartition(b'/')[-1].replace(b'\\', b'\\\\').replace(b'"', b'\\"')

    )

    web.res.headers[b'Content-Disposition'] = (

        b'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]

            or r'application/octet-stream'

        )

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

    def lines(context):

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

            yield {

                b"line": t,

                b"lineid": b"l%d" % (lineno + 1),

                b"linenumber": b"% 6d" % (lineno + 1),

                b"parity": next(parity),

            }

    return web.sendtemplate(

        b'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),

        **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))

    )

@webcommand(b'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(b'style') == b'raw':

        return rawfile(web)

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

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

    MODE_KEYWORD = b'keyword'

    MODE_REVSET = b'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:

                if not (

                    q in lower(ctx.user())

                    or q in lower(ctx.description())

                    or q in lower(b" ".join(ctx.files()))

                ):

                    miss = 1

                    break

            if miss:

                continue

            yield ctx

    def revsetsearch(revs):

        for r in revs:

            yield web.repo[r]

    searchfuncs = {

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

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

        MODE_REVSET: (revsetsearch, b'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 = b'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

        if any(

            (token, (value or b'')[:3]) == (b'string', b're:')

            for token, value, pos in revsetlang.tokenize(revdef)

        ):

            return MODE_KEYWORD, query

        funcsused = revsetlang.funcsused(tree)

        if not funcsused.issubset(revset.safesymbols):

            return MODE_KEYWORD, query

        try:

            mfunc = revset.match(

                web.repo.ui, revdef, lookup=revset.lookupfn(web.repo)

            )

            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

        except (

            error.ParseError,

            error.RepoLookupError,

            error.Abort,

            LookupError,

        ):

            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, b'changelogtag', n)

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

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

            lm.update(

                {

                    b'parity': next(parity),

                    b'changelogtag': showtags,

                    b'files': files,

                }

            )

            yield lm

            if count >= revcount:

                break

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

    revcount = web.maxchanges

    if b'revcount' in web.req.qsparams:

        try:

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

            revcount = max(revcount, 1)

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

        except ValueError:

            pass

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

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

    lessvars[b'rev'] = query

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

    morevars[b'revcount'] = revcount * 2

    morevars[b'rev'] = query

    mode, funcarg = getsearchmode(query)

    if b'forcekw' in web.req.qsparams:

        showforcekw = b''

        showunforcekw = searchfuncs[mode][1]

        mode = MODE_KEYWORD

        funcarg = query

    else:

        if mode != MODE_KEYWORD:

            showforcekw = searchfuncs[MODE_KEYWORD][1]

        else:

            showforcekw = b''

        showunforcekw = b''

    searchfunc = searchfuncs[mode]

    tip = web.repo[b'tip']

    parity = paritygen(web.stripecount)

    return web.sendtemplate(

        b'search',

        query=query,

        node=tip.hex(),

        symrev=b'tip',

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

        archives=web.archivelist(b'tip'),

        morevars=morevars,

        lessvars=lessvars,

        modedesc=searchfunc[1],

        showforcekw=showforcekw,