#

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

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,

    HTTP_OK,

    get_contact,

    paritygen,

    staticfile,

)

from .. import (

    archival,

    context,

    encoding,

    error,

    graphmod,

    revset,

    revsetlang,

    scmutil,

    smartset,

    templatefilters,

    templater,

    util,

)

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.

    Usage:

    @webcommand('mycommand')

    def mycommand(web, req, tmpl):

        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, req, tmpl):

    """

    /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 'file' in req.form and req.form['file'][0]:

        return filelog(web, req, tmpl)

    else:

        return changelog(web, req, tmpl)

@webcommand('rawfile')

def rawfile(web, req, tmpl):

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

    path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])

    if not path:

        content = manifest(web, req, tmpl)

        req.respond(HTTP_OK, web.ctype)

        return content

    try:

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

    except error.LookupError as inst:

        try:

            content = manifest(web, req, tmpl)

            req.respond(HTTP_OK, web.ctype)

            return content

        except ErrorResponse:

            raise inst

    path = fctx.path()

    text = fctx.data()

    mt = 'application/binary'

    if guessmime:

        mt = mimetypes.guess_type(path)[0]

        if mt is None:

            if util.binary(text):

                mt = 'application/binary'

            else:

                mt = 'text/plain'

    if mt.startswith('text/'):

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

    req.respond(HTTP_OK, mt, path, body=text)

    return []

def _filerevision(web, req, tmpl, fctx):

    f = fctx.path()

    text = fctx.data()

    parity = paritygen(web.stripecount)

    if util.binary(text):

        mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'

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

    def lines():

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

            yield {"line": t,

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

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

                   "parity": next(parity)}

    return tmpl("filerevision",

                file=f,

                path=webutil.up(f),

                text=lines(),

                symrev=webutil.symrevorshortnode(req, fctx),

                rename=webutil.renamelink(fctx),

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

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

@webcommand('file')

def file(web, req, tmpl):

    """

    /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.

    """

    path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])

    if not path:

        return manifest(web, req, tmpl)

    try:

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

    except error.LookupError as inst:

        try:

            return manifest(web, req, tmpl)

        except ErrorResponse:

            raise inst

def _search(web, req, tmpl):

    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 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(" ".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, 'exact revision search'),

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

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

    }

    def getsearchmode(query):

        try:

            ctx = 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

        if any((token, (value or '')[:3]) == ('string', '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

        mfunc = revset.match(web.repo.ui, revdef)

        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

        except (error.ParseError, error.RepoLookupError, error.Abort,

                LookupError):

            return MODE_KEYWORD, query

    def changelist(**map):

        count = 0

        for ctx in searchfunc[0](funcarg):

            count += 1

            n = ctx.node()

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

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

            yield tmpl('searchentry',

                       parity=next(parity),

                       changelogtag=showtags,

                       files=files,

                       **webutil.commonentry(web.repo, ctx))

            if count >= revcount:

                break

    query = req.form['rev'][0]

    revcount = web.maxchanges

    if 'revcount' in req.form:

        try:

            revcount = int(req.form.get('revcount', [revcount])[0])

            revcount = max(revcount, 1)

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

        except ValueError:

            pass

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

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

    lessvars['rev'] = query

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

    morevars['revcount'] = revcount * 2

    morevars['rev'] = query

    mode, funcarg = getsearchmode(query)

    if 'forcekw' in req.form:

        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 tmpl('search', query=query, node=tip.hex(), symrev='tip',

                entries=changelist, archives=web.archivelist("tip"),

                morevars=morevars, lessvars=lessvars,

                modedesc=searchfunc[1],

                showforcekw=showforcekw, showunforcekw=showunforcekw)

@webcommand('changelog')

def changelog(web, req, tmpl, 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 req.form:

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

        symrev = webutil.symrevorshortnode(req, ctx)

    elif 'rev' in req.form:

        return _search(web, req, tmpl)

    else:

        ctx = web.repo['tip']

        symrev = 'tip'

    def changelist():

        revs = []

        if pos != -1:

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

        curcount = 0

        for rev in revs:

            curcount += 1

            if curcount > revcount + 1:

                break

            entry = webutil.changelistentry(web, web.repo[rev], tmpl)

            entry['parity'] = next(parity)

            yield entry

    if shortlog:

        revcount = web.maxshortchanges

    else: