from nevow import loaders, rend, static
from nevow.tags import *

import parseHistory, re, os, metaplay, recordbot

def attrsort(L, attr):
    L.sort(lambda x,y:cmp(getattr(x, attr), getattr(y, attr)))
    return L

basecats = ['ER', 'EH', 'NR', 'NH']
cats = []
for s in ['', '2', '3', '4', '5', '6', '7']:
    for cat in basecats:
        cats.append(cat + s)

# /
# /player/
# /player/<name>/
# /~mwh/recordbot/level/
# /~mwh/recordbot/level/<name>/
# /~mwh/recordbot/level/<name>/<cat>/
# /~mwh/recordbot/level/<name>/<cat>/record
# /~mwh/recordbot/level/<name>/<cat>/<time>

DIST = 4

def level_neighbours(self, context, data):
    c = self.config
    l = self.level

    r = []

    for i in range(l.seqno - DIST, l.seqno + DIST + 1):
        if 0 <= i < len(c.levelseq):
            ll = c.levelseq[i]
            r.append(a(href='/~mwh/recordbot/~mwh/recordbot/level/'+ll.name)[ll.name])
            r.append(' - ')
    if l.seqno - DIST > 0:
        r.insert(0, '... -')
    if l.seqno + DIST + 1 < len(c.levelseq):
        r.append('...')
    else:
        del r[-1]
    return r

def cat_neighbours(self, context, data):
    c = self.config
    l = self.level

    r = []

    cs = l.demos.keys()
    cs.sort(recordbot.cmpskill)

    for i in range(len(cs)):
        r.append(a(href='/~mwh/recordbot/~mwh/recordbot/level/'+l.name+'/'+cs[i])[cs[i]])
        r.append(' - ')
    del r[-1:]
    return r


def time_neighbours(self, context, data):
    ds = self.level.demos.get(self.cat, [])[:]
    attrsort(ds, "parsedtime")
    ds.reverse()
    r = []
    for t in [a(href=d.time.replace(':', ''))[d.time]
              for d in ds]:
        r.append(t)
        r.append(' - ')
    del r[-1:]
    return r

class BasePage(rend.Page, metaplay.AutoReloader):
    docFactory = loaders.htmlfile('templates/page.html')

    child_css = static.File('static/css')

    def render_content(self, subrenderer):
        def foo(context, data):
            tag = context.tag.clear()
            return tag[self.renderer(context, subrenderer)]
        return foo

    def render_title(self, context, data):
        return getattr(self, "title", self.__class__.__name__)

    def render_body(self, context, data):
        return self.bodyFactory

    def render_level_neighbours(self, context, data):
        c = self.config
        l = self.level

        r = []

        for i in range(l.seqno - DIST, l.seqno + DIST + 1):
            if 0 <= i < len(c.levelseq):
                ll = c.levelseq[i]
                r.append(a(href='/~mwh/recordbot/level/'+ll.name)[ll.name])
                r.append(' - ')
        if l.seqno - DIST > 0:
            r.insert(0, '... -')
        if l.seqno + DIST + 1 < len(c.levelseq):
            r.append('...')
        else:
            del r[-1]
        return r


    def render_cat_neighbours(self, context, data):
        c = self.config
        l = self.level

        r = []

        cs = sorted(self.level.demos.keys(), recordbot.cmpskill)

        for i in range(len(cs)):
            r.append(a(href='/~mwh/recordbot/level/'+l.name+'/'+cs[i])[cs[i]])
            r.append(' - ')
        del r[-1:]
        return r


    def render_time_neighbours(self, context, data):
        ds = self.level.demos.get(self.cat, [])[:]
        attrsort(ds, "parsedtime")
        ds.reverse()
        r = []
        def mka(d):
            return a(href="/~mwh/recordbot/level/%s/%s/%s"%(
                d.level.name, d.cat,
                d.time.replace(':', '')))[d.time]
        for d in ds:
            r.append(mka(d))
            r.append(' - ')
        del r[-1:]
        return r

    def render_level(self, demo):
        return a(href='/~mwh/recordbot/level/%s/'%(demo.level.name,))[b[demo.level.name]]

    def render_cat(self, demo):
        return a(href='/~mwh/recordbot/level/%s/%s/'%(demo.level.name, demo.cat))[b[demo.cat]]

    def render_time(self, demo):
        return a(href='/~mwh/recordbot/level/%s/%s/%s'%(demo.level.name, demo.cat,
                                         demo.time.replace(':', '')))[demo.time]

    def render_pname(self, demo):
        r = []
        for t in [a(href='/player/%s'%(pl.page,))[pl.name] for pl in demo.players]:
            r.append(t)
            r.append('/')
        del r[-1]
        return r

    def render_date(self, demo):
        return demo.date


class Root(BasePage):
    addSlash = '/'
    bodyFactory = loaders.htmlfile('templates/root.html')


class Form(BasePage):
    addSlash = '/'
    bodyFactory = loaders.htmlfile('templates/form.html')
    title = "Demo Query"

    def __init__(self, config):
        super(Form, self).__init__()
        self.config = config

    def render_input(self, cat):
        def r(context, data):
            if context.arg(cat):
                context.tag(checked=1)
            return context.tag(name=cat)[cat]
        return r

    def render_field(self, field):
        def r(context, data):
            return context.tag(value=context.arg(field, ''),
                               name=field)
        return r

    def render_isrec(self, context, data):
        if data.record:
            return '*'
        else:
            return ''

    def render_resultlen(self, context, data):
        lpat = re.compile(context.arg("level", ""))
        ppat = re.compile(unicode(context.arg("player", ""), 'utf-8'), re.I)
        if context.arg("level", "") + context.arg("player", "") == '':
            context.parent.parent.parent.remember([], IHand)
            return "boo"
        levels = []
        for l, level in self.config.levels.iteritems():
            if lpat.match(l):
                levels.append(level)
        attrsort(levels, "seqno")
        ourcats = [c for c in basecats if context.arg(c[:2])]
        ps = [str(i) for i in range(2, 10) if context.arg(str(i)+'p')]
        if context.arg('1p'):
            ps.insert(0, '')
        ourcats2 = []
        for p in ps:
            for c in ourcats:
                ourcats2.append(c + p)
        recs = context.arg("Show Records")
        olds = context.arg("Show Old Demos")
        results = []
        for level in levels:
            for cat in ourcats2:
                demos = level.demos.get(cat, [])
                for demo in demos[::-1]:
                    cands = []
                    for p in demo.players:
                        if ppat.search(p.name):
                            cands.append(demo)
                            break
                    for demo in cands:
                        if (demo.record and recs) or (not demo.record and olds):
                            results.append(demo)
        context.parent.parent.parent.remember(results, IHand)
        return len(results)

    def data_demos(self, context, data):
        return context.locate(IHand)

class Players(BasePage):
    bodyFactory = loaders.htmlfile('templates/players.html')
    addSlash = True
    title = "Players"

    def __init__(self, config):
        super(Players, self).__init__()
        self.config = config

    def data_players(self, context, data):
        d = self.config.players.values()
        d = [p for p in d if p.runs]
        k = context.arg('key', 'records')
        r = False
        if k[0] == '-':
            k = k[1:]
            r = True
        k = {
            'runs':lambda p:-len(p.runs),
            'records':lambda p:-len([r for r in p.runs if r.record]),
            'name':lambda p:p.name.split()[-1].lower(),
            }[k]
        d = [(k(p), p) for p in d]
        d.sort()
        if r:
            d.reverse()
        d = [t[1] for t in d]
        return d

    def render_name(self, context, data):
        n = data.name.encode('utf-8')
        return a(href=data.page)[n]

    def render_numrecords(self, context, data):
        return len([r for r in data.runs if r.record])

    def render_numdemos(self, context, data):
        return len(data.runs)

    def childFactory(self, ctw, name):
        if name in self.config.player_pages:
            return Player(self.config.player_pages[name])


class Player(BasePage):
    bodyFactory = loaders.htmlfile('templates/player.html')

    def __init__(self, player):
        super(Player, self).__init__()
        self.player = player

    def render_name(self, context, data):
        n = self.player.name.encode('utf-8')
        return n

    def render_numdemos(self, context, data):
        return len(self.player.runs)

    def render_numrecords(self, context, data):
        return len([r for r in self.player.runs if r.record])

    def data_records(self, context, data):
        records = [r for r in self.player.runs if r.record]
        cats = ['ER', 'EH', 'NR', 'NH']
        result = []
        for s in ['', '2', '3', '4', '5', '6', '7']:
            for cat in cats:
                this = []
                for r in records:
                    if r.cat == cat + s:
                        this.append(r)
                this.sort(lambda x,y:cmp(x.level.seqno, y.level.seqno))
                result.extend(this)
        self._cat = ''
        return result

    def render_level(self, context, data):
        return a(href='/~mwh/recordbot/level/'+data.level.name)[data.level.name]

    def render_levelname(self, context, data):
        return data.level.title

    def render_cat(self, context, data):
        if self._cat != data.cat:
            self._cat = data.cat
            return data.cat
        else:
            return ''


class Levels(BasePage):
    addSlash = True

    def __init__(self, config):
        super(Levels, self).__init__()
        self.config = config

    def render_list(self, context, data):
        levels = self.config.levels.values()
        attrsort(levels, "seqno")
        return ul[[li[a(href=l.name)[l.name + " - " + l.title]] for l in levels]]

    def childFactory(self, ctx, name):
        if name in self.config.levels:
            return Level(self.config, self.config.levels[name])

    bodyFactory = loaders.stan(
        body[p(render=render_list)])


class Level(BasePage):
    addSlash = True

    def __init__(self, config, level):
        super(Level, self).__init__()
        self.level = level
        self.config = config

    def render_title(self, context, data):
        return "%s - %s"%(self.level.name, self.level.title)

    def data_demos(self, context, data):
        cs = sorted(self.level.demos.keys(), recordbot.cmpskill)
        self._cat = ''
        for c in cs:
            for demo in  self.level.demos[c][::-1]:
                yield demo

    def render_cat(self, demo):
        if self._cat != demo.cat:
            self._cat = demo.cat
            return a(href=demo.cat)[b[demo.cat]]
        else:
            return ''

    bodyFactory = loaders.htmlfile("templates/level.html")

    def childFactory(self, ctx, name):
        if recordbot.plausible_cat(name):
            return Category(self.config, self.level, name)

class Category(BasePage):
    addSlash = True

    def __init__(self, config, level, cat):
        super(Category, self).__init__()
        self.config = config
        self.level = level
        self.cat = cat

    def render_title(self, context, data):
        return "%s - %s - %s"%(self.level.name, self.level.title,
                               self.cat)

    def render_head(self, context, data):
        return [a(href='/~mwh/recordbot/level/'+self.level.name)[self.level.name],
                " - %s - %s"%(self.level.title, self.cat)]

    def data_demos(self, context, data):
        return self.level.demos.get(self.cat, [])[::-1]

    bodyFactory = loaders.htmlfile("templates/category.html")

    def child_record(self, request):
        return Demo(self.config,  self.level.records[self.cat])

    def childFactory(self, ctx, name):
        for d in self.level.demos[self.cat]:
            if d.time.replace(':', '') == name:
                return Demo(self.config, d)

class Demo(BasePage):
    def __init__(self, config, demo):
        super(Demo, self).__init__()
        self.config = config
        self.demo = demo
        self.level = demo.level
        self.cat = demo.cat

    def render_title(self, context, data):
        return [self.demo.level.name,
                ' - ',
                self.demo.level.title,
                ' - ',
                self.demo.cat,
                ' - ',
                self.demo.time]

    def render_head(self, context, data):
        return [a(href='/~mwh/recordbot/level/'+self.demo.level.name)[self.demo.level.name],
                ' - ',
                self.demo.level.title,
                ' - ',
                a(href='/~mwh/recordbot/level/'+self.demo.level.name + '/'+self.demo.cat)[self.demo.cat],
                ]

    def render_txt(self, context, data):
        if self.demo.location is None:
            return "this demo is no longer available."
        try:
            import cgi
            fname = os.path.basename(self.demo.location)
            fname = fname[:-2] + 'txt'
            escaped = cgi.escape(open('txts/%s/%s'%(self.demo.cat, fname)).read())
            def repl(match):
                return '&nbsp;'*len(match.group(0))
            spaced = re.sub('  +', repl, escaped)
            return raw(spaced.replace('\n', '<br />'))
        except IOError:
            # ok, the txt isn't there
            return "can't find txt!"

    def render_sum(self, context, data):
        return p[self.demo.date,
                 ' ',
                 self.render_pname(self.demo),
                 ' ',
                 self.demo.time]

    bodyFactory = loaders.htmlfile("templates/demo.html")


from nevow.inevow import IRequest, IHand, IResource, ISession
from formless import iformless

class Bot(rend.Page, metaplay.AutoReloader):

    def __init__(self, factory):
        super(Bot, self).__init__()
        self.f = factory

    def render_output(self, context, data):
        command = context.arg("command")
        if not command:
            return ''
        c = command
        command = command.split()
        data = []
        def reply(*l):
            data.append(l)
            data.append('\n')
        reply.line = c
        reply.session = ISession(context)
        reply.channel = None
        reply.theuser = None
        self.f.command(reply, command)
        return pre[data]

    def render_text(self, context, data):
        return context.arg("command", "")

    docFactory = loaders.stan(
        html[head[title["Bot-a-like"],
                  style(type='text/css')['a { text-decoration: none }']],
             body[h3["Bot-a-like"],
                  p(render=render_output),
                  form[input(type="text", name="command", size=40,
                            value=render_text),
                       input(type="submit", value="submit")]]])

class Cand(rend.Page, metaplay.AutoReloader):

    def __init__(self, config):
        super(Cand, self).__init__()
        self.config = config

    def render_output(self, context, data):
        import datetime, re
        year = context.arg("year")
        if not year:
            return ''
        const = context.arg("const")
        if not const:
            return ''
        const = const.split()
        varying = context.arg("varying")
        if varying is None:
            return ''
        varying = varying.split(',')
        if varying == []:
            varying = ['']
        try:
            year = int(year)
        except ValueError:
            return 'invalid year'
        start = datetime.date(year, 1, 1)
        end = datetime.date(year + 1, 1, 1)
        from feature import parse_feature_flags, NumbskullError
        y = []
        from nolans import fmtplayers
        for d in self.config.all_demos():
            if start <= d.parseddate < end:
                y.append(d)
        y.sort(lambda x,y:cmp(x.parseddate, y.parseddate))
        y.sort(lambda x,y:cmp(x.level.seqno, y.level.seqno))
        s = []
        for v in varying:
            v = v.split()
            try:
                fr = parse_feature_flags(const + v)
            except NumbskullError:
                return 'invalid features'
            r = fr.filter(y)
            s.append([p[', '.join(fr.annotation), " ", len(r), " candidates"],
                      ul[[li[tt["%s %s by %s"%(d.cat, d.filename, fmtplayers(d))]] for d in r]]])
        return s

    def render_year(self, context, data):
        import datetime
        return context.arg("year", datetime.date.today().year)

    def render_const(self, context, data):
        return context.arg("const", "+id +sp -mara")

    def render_varying(self, context, data):
        return context.arg("varying", "+er, +eh, +nr, +nh")

    docFactory = loaders.stan(
        html[head[title["Candidates"]],
             body[h3["Candidates"],
                  p(render=render_output),
                  form["Year: ",
                       input(type="text", name="year", size=40,
                             value=render_year),
                       br,
                       "Constant: ",
                       input(type="text", name="const", size=40,
                             value=render_const),
                       br,
                       "Varying: ",
                       input(type="text", name="varying", size=40,
                             value=render_varying),
                       br,
                       input(type="submit", value="submit")]]])

class HistoryTxt(object):
    __implements__ = IResource,

    def __init__(self, config):
        self.config = config

    def locateChild(self, request, segments):
        """Locate another object which can be adapted to IResource
        Return a tuple of resource, path segments
        """
        return None

    def renderHTTP(self, request):
        """Render a request
        """
        import unparseHistory
        request.setHeader('content-type', 'text/plain')
        return "\n".join(unparseHistory.unparseHistory(self.config))

class Reloader(object):
    __implements__ = IResource,

    def locateChild(self, request, segments):
        """Locate another object which can be adapted to IResource
        Return a tuple of resource, path segments
        """
        return None

    def renderHTTP(self, request):
        """Render a request
        """
        import webby
        reload(webby)
        import unparseHistory
        reload(unparseHistory)
        import nolans
        reload(nolans)
        import linecache
        linecache.clearcache()
        request.setResponseCode(301)
        request.setHeader('location', request.getHeader('referer', '/'))