import os, sys
import tg, pylons
from webob.exc import HTTPNotFound

from bazbase import conversion, model, translators
from bazki import getting
from gameki import restricted

def foreach_markup(list_expr, color=None, ancestor=None, group=None,
                   owned=None, let='', propname=u'product'):
    # <<foreach e>><<cache e.product owner=owner/>><</foreach>>
    markup  = "<<foreach %s o" % list_expr
    if color is not None:
        markup += " (o.group.color == %s)" % repr(color)
    if ancestor is not None:
        markup += " has_ancestor(o, %s)" % ancestor.ename
    if group is not None:
        markup += " (o.group == %s)" % group.ename
    if owned is not None:
        markup += " (o.owned == %s)" % owned
    markup += ">>\n"
    markup += "  <<cache o.%s %s/>>\n" % (propname, let)
    markup += "  <<cleardoublepage/>>\n"
    markup += "<</foreach>>\n\n"
    return markup

def markup_for_user(u, color=None, ancestor=None, group=None,
                    mode=None, display=""):
    """display should be a baz_eval expression."""

    if mode != 'full' and mode is not None:
        propname = mode
    else:
        propname = u'product'
    
    markup = '<<withheaders %s.name %s>>\n' % (u.ename, display)
    markup += foreach_markup(
        "recursive_get(%s, 'stuff', 'exclude', folded=False)" % (u.ename),
        color, ancestor, group, owned=True, let="owner=%s" % u.ename,
        propname=propname)
    # For stuff that's not owned, don't set owner at all, so all
    # instances of the same item must be identical and get cached in the
    # same slot.
    markup += foreach_markup(
        "recursive_get(%s, 'stuff', 'exclude', folded=False)" % (u.ename),
        color, ancestor, group, owned=False, propname=propname)
    
    if color is not None or ancestor.isRoot():
        markup += "<<if hasattr(%s, 'badge')" % u.ename
        if color is not None:
            markup += " and %s.badgecolor == %s" % (u.ename, repr(color))
        markup += ">>\n"
        markup += "  <<cache %s.badge />>\n" % u.ename
        markup += "<</if>>\n\n"

    if mode == 'full':
        markup += '<<secret>>\n'

        markup += foreach_markup(
            "recursive_get(%s, 'stuff', 'invert', folded=False)" % (u.ename),
            color, ancestor, group, owned=True, let="owner=%s" % u.ename,
            propname=propname)

        markup += foreach_markup(
            "recursive_get(%s, 'stuff', 'invert', folded=False)" % (u.ename),
            color, ancestor, group, owned=False, propname=propname)
        
        markup += '<</secret>>\n'

    markup += '<</withheaders>>\n'
    return markup


class Printer(tg.TGController):

    @tg.expose()
    def _default(self, user, name=None, mode=None):
        if name is None:
            user, type = getting.filename_split(user)
            name = u'Object'
        elif mode is None:
            name, type = getting.filename_split(name)
            name = name.replace('_', ' ')
            name = unicode(name, 'utf-8')
        else:
            mode, type = getting.filename_split(mode)
        if name == 'all':
            name = u'Object'

        packet_group = model.Element.get(u'PacketGroup')
        if name[0].isupper():
            ancestor = model.Element.get(name)
            if packet_group.isAncestorOf(ancestor):
                group = ancestor
                ancestor = None
                display = "%s.name" % group.ename
            else:
                group = None
                if ancestor.isRoot():
                    display = '"Packet"'
                else:
                    display = '"%s"' % ancestor.ename
            color = None
        else:
            color = name
            ancestor = None
            group = None
            display = '"%s"' % color.capitalize()

        if mode is not None:
            if not restricted.is_omniscient():
                raise restricted.omniscient_only()

        if type == '.default':
            type = getting.DEFAULT_DEFAULT

        if user == 'compendium':
            if not restricted.is_omniscient():
                raise restricted.omniscient_only()
            if mode is None:
                mode = u'product'
            markup = foreach_markup("Owner", color, ancestor, group,
                                    propname=mode)
        elif user == 'production':
            if not restricted.is_omniscient():
                raise restricted.omniscient_only()
            users = model.Element.get(u'PC').getDescendants()
            markup = ""
            for u in users:
                markup += markup_for_user(
                    u, color, ancestor, group, mode='full',
                    display=display)
        else:
            logged_in_username = restricted.logged_in_username()
            if not restricted.is_omniscient() and user != logged_in_username:
                raise restricted.not_you()
            markup = markup_for_user(
                model.Element.get_raw(username=user), color, ancestor, group,
                mode=mode, display=display)

        if mode is None:
            pdfurl = tg.url('/print/%s/%s.pdf' % (user, name))
        else:
            pdfurl = tg.url('/print/%s/%s/%s.pdf' % (user, name, mode))

        global_metadata = {'title': u'Gameki Printing',
                           'pdfurl': pdfurl}
        print >>sys.stderr, markup
        try:
            ret = conversion.convert_markup(markup, type,
                                            global_metadata,
                                            cacheable_as='/print/%s/%s/%s'
                                            % (user, name, mode))
        except conversion.ConversionFailedException,e:
            raise HTTPNotFound(e)
        ctype, enc = translators.guess_type(name+type)
        
        if not isinstance(ret,str):
            # TG doesn't like buffers or unicode.
            ret = str(ret)
    
        if ctype:
            pylons.response.headers['Content-type'] = ctype + '; charset=utf-8'
        return ret