#

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

import os, mimetypes, re, cgi, copy

import webutil

from mercurial import error, archival, templater, templatefilters

from mercurial.node import short, hex

from mercurial.util import binary

from common import paritygen, staticfile, get_contact, ErrorResponse

from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND

from mercurial import graphmod, util

# __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', 'summary', 'filediff', 'diff', 'annotate', 'filelog',

   'archive', 'static', 'graph',

]

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

    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 = mimetypes.guess_type(path)[0]

    if mt is None:

        mt = binary(text) and 'application/octet-stream' or 'text/plain'

    req.respond(HTTP_OK, mt, path, len(text))

    return [text]

def _filerevision(web, tmpl, fctx):

    f = fctx.path()

    text = fctx.data()

    parity = paritygen(web.stripecount)

    if 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(1)):

            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=hex(fctx.node()),

                author=fctx.user(),

                date=fctx.date(),

                desc=fctx.description(),

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

    def changelist(**map):

        cl = web.repo.changelog

        count = 0

        qw = query.lower().split()

        def revgen():

            for i in xrange(len(cl) - 1, 0, -100):

                l = []

                for j in xrange(max(0, i - 100), i + 1):

                    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 ctx.user().lower() or

                        q in ctx.description().lower() or

                        q in " ".join(ctx.files()).lower()):

                    miss = 1

                    break

            if miss:

                continue

            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(),

                       date=ctx.date(),

                       files=files,

                       rev=ctx.rev(),

                       node=hex(n),

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

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

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

            if count >= web.maxchanges:

                break

    cl = web.repo.changelog

    parity = paritygen(web.stripecount)

    return tmpl('search',

                query=query,

                node=hex(cl.tip()),

                entries=changelist,

                archives=web.archivelist("tip"))

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

    if 'node' in req.form:

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

    else:

        if 'rev' in req.form:

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

        else:

            hi = len(web.repo) - 1

        try:

            ctx = web.repo[hi]

        except error.RepoError:

            return _search(web, tmpl, hi) # XXX redirect to 404 page?

    def changelist(limit=0, **map):

        l = [] # build a list in forward order for efficiency

        for i in xrange(start, end):

            ctx = web.repo[i]

            n = ctx.node()

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

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

            l.insert(0, {"parity": parity.next(),

                         "author": ctx.user(),

                         "parent": webutil.parents(ctx, i - 1),

                         "child": webutil.children(ctx, i + 1),

                         "changelogtag": showtags,

                         "desc": ctx.description(),

                         "date": ctx.date(),

                         "files": files,

                         "rev": i,

                         "node": hex(n),

                         "tags": webutil.nodetagsdict(web.repo, n),

                         "inbranch": webutil.nodeinbranch(web.repo, ctx),

                         "branches": webutil.nodebranchdict(web.repo, ctx)

                        })

        if limit > 0:

            l = l[:limit]

        for e in l:

            yield e

    maxchanges = shortlog and web.maxshortchanges or web.maxchanges

    cl = web.repo.changelog

    count = len(cl)

    pos = ctx.rev()

    start = max(0, pos - maxchanges + 1)

    end = min(count, start + maxchanges)

    pos = end - 1

    parity = paritygen(web.stripecount, offset=start-end)

    changenav = webutil.revnavgen(pos, maxchanges, count, web.repo.changectx)

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

                changenav=changenav,

                node=hex(ctx.node()),

                rev=pos, changesets=count,

                entries=lambda **x: changelist(limit=0,**x),

                latestentry=lambda **x: changelist(limit=1,**x),

                archives=web.archivelist("tip"))

def shortlog(web, req, tmpl):

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

def changeset(web, req, tmpl):

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

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

    showbranch = webutil.nodebranchnodefault(ctx)

    files = []

    parity = paritygen(web.stripecount)

    for f in ctx.files():

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

        files.append(tmpl(template,

                          node=ctx.hex(), file=f,

                          parity=parity.next()))

    parity = paritygen(web.stripecount)

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

    return tmpl('changeset',

                diff=diffs,

                rev=ctx.rev(),

                node=ctx.hex(),

                parent=webutil.parents(ctx),

                child=webutil.children(ctx),

                changesettag=showtags,

                changesetbranch=showbranch,

                author=ctx.user(),

                desc=ctx.description(),

                date=ctx.date(),

                files=files,

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

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

                branch=webutil.nodebranchnodefault(ctx),

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

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

rev = changeset

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 f, n in mf.iteritems():

        if f[:l] != path:

            continue

        remain = f[l:]

        elements = remain.split('/')

        if len(elements) == 1:

            files[remain] = f

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

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

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

def tags(web, req, tmpl):

    i = web.repo.tagslist()

    i.reverse()

    parity = paritygen(web.stripecount)

    def entries(notip=False,limit=0, **map):

        count = 0

        for k, n in i:

            if notip and k == "tip":

                continue

            if limit > 0 and count >= limit:

                continue

            count = count + 1

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

                   "tag": k,