#

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

import os, mimetypes, re, cgi, copy

import webutil

from mercurial import error, encoding, archival, templater, templatefilters

from mercurial.node import short, hex

from mercurial import util

from common import paritygen, staticfile, get_contact, ErrorResponse

from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND

from mercurial import graphmod, patch

from mercurial import scmutil

from mercurial.i18n import _

from mercurial.error import ParseError, RepoLookupError, Abort

from mercurial import revset

__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, 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 []

    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": parity.next()}

    return tmpl("filerevision",

                file=f,

                path=webutil.up(f),

                text=lines(),

                rev=fctx.rev(),

                node=fctx.hex(),

                author=fctx.user(),

                date=fctx.date(),

                desc=fctx.description(),

                extra=fctx.extra(),

                branch=webutil.nodebranchnodefault(fctx),

                parent=webutil.parents(fctx),

                child=webutil.children(fctx),

                rename=webutil.renamelink(fctx),

                tags=webutil.nodetagsdict(web.repo, fctx.node()),

                bookmarks=webutil.nodebookmarksdict(web.repo, fctx.node()),

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

@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:

    except error.LookupError, 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 = revset.parse(revdef)

        except ParseError:

            # can't parse to a revset tree

            return MODE_KEYWORD, query

        if revset.depth(tree) <= 2:

            # no revset syntax used

            return MODE_KEYWORD, query

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

                    for token, value, pos in revset.tokenize(revdef)):

            return MODE_KEYWORD, query

        funcsused = revset.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 (ParseError, RepoLookupError, 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=parity.next(),

                       author=ctx.user(),

                       parent=webutil.parents(ctx),

                       child=webutil.children(ctx),

                       changelogtag=showtags,

                       desc=ctx.description(),

                       extra=ctx.extra(),

                       date=ctx.date(),

                       files=files,

                       rev=ctx.rev(),

                       node=hex(n),

                       tags=webutil.nodetagsdict(web.repo, n),

                       bookmarks=webutil.nodebookmarksdict(web.repo, n),

                       inbranch=webutil.nodeinbranch(web.repo, ctx),

                       branches=webutil.nodebranchdict(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)

                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)

    elif 'rev' in req.form:

        return _search(web, req, tmpl)

    else:

        ctx = web.repo['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'] = parity.next()

            yield entry

    if shortlog: