#

# 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 help as helpmod

from mercurial import scmutil

from mercurial.i18n import _

from mercurial.error import ParseError, RepoLookupError, Abort

from mercurial import revset

# __all__ is populated with the allowed commands. Be sure to add to it if

# you're adding a new command, or the new command won't work.

__all__ = [

   'log', 'rawfile', 'file', 'changelog', 'shortlog', 'changeset', 'rev',

   'manifest', 'tags', 'bookmarks', 'branches', 'summary', 'filediff', 'diff',

   'comparison', 'annotate', 'filelog', 'archive', 'static', 'graph', 'help',

]

def log(web, req, tmpl):

    if 'file' in req.form and req.form['file'][0]:

        return filelog(web, req, tmpl)

    else:

        return changelog(web, req, tmpl)

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:

            mt = util.binary(text) and 'application/binary' or 'text/plain'

    if mt.startswith('text/'):

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

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

    return []

def _filerevision(web, 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": 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),

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

def file(web, req, tmpl):

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

    if not path:

        return manifest(web, req, tmpl)

    try:

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

    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, pos = 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 util.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, revset.baseset(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)

    return tmpl('search', query=query, node=tip.hex(),

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

                morevars=morevars, lessvars=lessvars,

                modedesc=searchfunc[1],

                showforcekw=showforcekw, showunforcekw=showunforcekw)

def changelog(web, req, tmpl, shortlog=False):

    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

            curcount += 1

            if curcount > revcount + 1:

                break

    revcount = shortlog and web.maxshortchanges or 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)

    morevars = copy.copy(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())

    latestentry = entries[:1]

    if len(entries) > revcount:

        nextentry = entries[-1:]

        entries = entries[:-1]

    else:

        nextentry = []

    return tmpl(shortlog and 'shortlog' or 'changelog', changenav=changenav,

                node=ctx.hex(), rev=pos, changesets=count,

                entries=entries,

                latestentry=latestentry, nextentry=nextentry,

                archives=web.archivelist("tip"), revcount=revcount,

                morevars=morevars, lessvars=lessvars, query=query)

def shortlog(web, req, tmpl):

    return changelog(web, req, tmpl, shortlog=True)

def changeset(web, req, tmpl):

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

    basectx = webutil.basechangectx(web.repo, req)

    if basectx is None:

        basectx = ctx.p1()

    showtags = webutil.showtag(web.repo, tmpl, 'changesettag', ctx.node())

    showbookmarks = webutil.showbookmark(web.repo, tmpl, 'changesetbookmark',

                                         ctx.node())

    showbranch = webutil.nodebranchnodefault(ctx)

    files = []

    parity = paritygen(web.stripecount)

    for blockno, f in enumerate(ctx.files()):

        template = f in ctx and 'filenodelink' or 'filenolink'

        files.append(tmpl(template,

                          node=ctx.hex(), file=f, blockno=blockno + 1,

                          parity=parity.next()))

    style = web.config('web', 'style', 'paper')

    if 'style' in req.form:

        style = req.form['style'][0]

    parity = paritygen(web.stripecount)

    diffs = webutil.diffs(web.repo, tmpl, ctx, basectx, None, parity, style)

    parity = paritygen(web.stripecount)

    diffstatgen = webutil.diffstatgen(ctx, basectx)

    diffstat = webutil.diffstat(tmpl, ctx, diffstatgen, parity)

    return tmpl('changeset',

                diff=diffs,

                rev=ctx.rev(),

                node=ctx.hex(),

                parent=tuple(webutil.parents(ctx)),

                child=webutil.children(ctx),

                basenode=basectx.hex(),

                changesettag=showtags,

                changesetbookmark=showbookmarks,

                changesetbranch=showbranch,

                author=ctx.user(),

                desc=ctx.description(),

                extra=ctx.extra(),

                date=ctx.date(),

                files=files,

                diffsummary=lambda **x: webutil.diffsummary(diffstatgen),

                diffstat=diffstat,

                archives=web.archivelist(ctx.hex()),

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

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

                branch=webutil.nodebranchnodefault(ctx),

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

                branches=webutil.nodebranchdict(web.repo, ctx))

rev = changeset

def decodepath(path):

    """Hook for mapping a path in the repository to a path in the

    working copy.

    Extensions (e.g., largefiles) can override this to remap files in

    the virtual file system presented by the manifest command below."""

    return path

def manifest(web, req, tmpl):

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

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

    mf = ctx.manifest()

    node = ctx.node()

    files = {}

    dirs = {}

    parity = paritygen(web.stripecount)

    if path and path[-1] != "/":

        path += "/"

    l = len(path)

    abspath = "/" + path

    for full, n in mf.iteritems():

        # the virtual path (working copy path) used for the full

        # (repository) path

        f = decodepath(full)

        if f[:l] != path:

            continue

        remain = f[l:]

        elements = remain.split('/')

        if len(elements) == 1:

            files[remain] = full

        else:

            h = dirs # need to retain ref to dirs (root)

            for elem in elements[0:-1]:

                if elem not in h:

                    h[elem] = {}

                h = h[elem]

                if len(h) > 1:

                    break

            h[None] = None # denotes files present

    if mf and not files and not dirs:

        raise ErrorResponse(HTTP_NOT_FOUND, 'path not found: ' + path)

    def filelist(**map):

        for f in sorted(files):

            full = files[f]

            fctx = ctx.filectx(full)

            yield {"file": full,

                   "parity": parity.next(),

                   "basename": f,

                   "date": fctx.date(),

                   "size": fctx.size(),

                   "permissions": mf.flags(full)}

    def dirlist(**map):

        for d in sorted(dirs):

            emptydirs = []

            h = dirs[d]

            while isinstance(h, dict) and len(h) == 1:

                k, v = h.items()[0]

                if v:

                    emptydirs.append(k)

                h = v

            path = "%s%s" % (abspath, d)

            yield {"parity": parity.next(),

                   "path": path,

                   "emptydirs": "/".join(emptydirs),

                   "basename": d}

    return tmpl("manifest",

                rev=ctx.rev(),

                node=hex(node),

                path=abspath,

                up=webutil.up(abspath),

                upparity=parity.next(),

                fentries=filelist,

                dentries=dirlist,

                archives=web.archivelist(hex(node)),

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

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

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

                branches=webutil.nodebranchdict(web.repo, ctx))

def tags(web, req, tmpl):

    i = list(reversed(web.repo.tagslist()))

    parity = paritygen(web.stripecount)

    def entries(notip, latestonly, **map):