"""Default tags used by the template system, available to all templates."""

import sys

import re

from itertools import cycle as itertools_cycle

try:

    reversed

except NameError:

    from django.utils.itercompat import reversed     # Python 2.3 fallback

from django.template import Node, NodeList, Template, Context, Variable

from django.template import TemplateSyntaxError, VariableDoesNotExist, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END, SINGLE_BRACE_START, SINGLE_BRACE_END, COMMENT_TAG_START, COMMENT_TAG_END

from django.template import get_library, Library, InvalidTemplateLibrary

from django.conf import settings

from django.utils.encoding import smart_str, smart_unicode

from django.utils.itercompat import groupby

from django.utils.safestring import mark_safe

register = Library()

class AutoEscapeControlNode(Node):

    """Implements the actions of the autoescape tag."""

    def __init__(self, setting, nodelist):

        self.setting, self.nodelist = setting, nodelist

    def render(self, context):

        old_setting = context.autoescape

        context.autoescape = self.setting

        output = self.nodelist.render(context)

        context.autoescape = old_setting

        if self.setting:

            return mark_safe(output)

        else:

            return output

class CommentNode(Node):

    def render(self, context):

        return ''

class CycleNode(Node):

    def __init__(self, cyclevars, variable_name=None):

        self.cycle_iter = itertools_cycle([Variable(v) for v in cyclevars])

        self.variable_name = variable_name

    def render(self, context):

        value = self.cycle_iter.next().resolve(context)

        if self.variable_name:

            context[self.variable_name] = value

        return value

class DebugNode(Node):

    def render(self, context):

        from pprint import pformat

        output = [pformat(val) for val in context]

        output.append('\n\n')

        output.append(pformat(sys.modules))

        return ''.join(output)

class FilterNode(Node):

    def __init__(self, filter_expr, nodelist):

        self.filter_expr, self.nodelist = filter_expr, nodelist

    def render(self, context):

        output = self.nodelist.render(context)

        # Apply filters.

        context.update({'var': output})

        filtered = self.filter_expr.resolve(context)

        context.pop()

        return filtered

class FirstOfNode(Node):

    def __init__(self, vars):

        self.vars = map(Variable, vars)

    def render(self, context):

        for var in self.vars:

            try:

                value = var.resolve(context)

            except VariableDoesNotExist:

                continue

            if value:

                return smart_unicode(value)

        return u''

class ForNode(Node):

    def __init__(self, loopvars, sequence, is_reversed, nodelist_loop):

        self.loopvars, self.sequence = loopvars, sequence

        self.is_reversed = is_reversed

        self.nodelist_loop = nodelist_loop

    def __repr__(self):

        reversed_text = self.is_reversed and ' reversed' or ''

        return "<For Node: for %s in %s, tail_len: %d%s>" % \

            (', '.join(self.loopvars), self.sequence, len(self.nodelist_loop),

             reversed_text)

    def __iter__(self):

        for node in self.nodelist_loop:

            yield node

    def get_nodes_by_type(self, nodetype):

        nodes = []

        if isinstance(self, nodetype):

            nodes.append(self)

        nodes.extend(self.nodelist_loop.get_nodes_by_type(nodetype))

        return nodes

    def render(self, context):

        nodelist = NodeList()

        if 'forloop' in context:

            parentloop = context['forloop']

        else:

            parentloop = {}

        context.push()

        try:

            values = self.sequence.resolve(context, True)

        except VariableDoesNotExist:

            values = []

        if values is None:

            values = []

        if not hasattr(values, '__len__'):

            values = list(values)

        len_values = len(values)

        if self.is_reversed:

            values = reversed(values)

        unpack = len(self.loopvars) > 1

        # Create a forloop value in the context.  We'll update counters on each

        # iteration just below.

        loop_dict = context['forloop'] = {'parentloop': parentloop}

        for i, item in enumerate(values):

            # Shortcuts for current loop iteration number.

            loop_dict['counter0'] = i

            loop_dict['counter'] = i+1

            # Reverse counter iteration numbers.

            loop_dict['revcounter'] = len_values - i

            loop_dict['revcounter0'] = len_values - i - 1

            # Boolean values designating first and last times through loop.

            loop_dict['first'] = (i == 0)

            loop_dict['last'] = (i == len_values - 1)

            if unpack:

                # If there are multiple loop variables, unpack the item into

                # them.

                context.update(dict(zip(self.loopvars, item)))

            else:

                context[self.loopvars[0]] = item

            for node in self.nodelist_loop:

                nodelist.append(node.render(context))

            if unpack:

                # The loop variables were pushed on to the context so pop them

                # off again. This is necessary because the tag lets the length

                # of loopvars differ to the length of each set of items and we

                # don't want to leave any vars from the previous loop on the

                # context.

                context.pop()

        context.pop()

        return nodelist.render(context)

class IfChangedNode(Node):

    def __init__(self, nodelist_true, nodelist_false, *varlist):

        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false

        self._last_seen = None

        self._varlist = map(Variable, varlist)

        self._id = str(id(self))

    def render(self, context):

        if 'forloop' in context and self._id not in context['forloop']:

            self._last_seen = None

            context['forloop'][self._id] = 1

        try:

            if self._varlist:

                # Consider multiple parameters.  This automatically behaves

                # like an OR evaluation of the multiple variables.

                compare_to = [var.resolve(context) for var in self._varlist]

            else:

                compare_to = self.nodelist_true.render(context)

        except VariableDoesNotExist:

            compare_to = None

        if compare_to != self._last_seen:

            firstloop = (self._last_seen == None)

            self._last_seen = compare_to

            context.push()

            context['ifchanged'] = {'firstloop': firstloop}

            content = self.nodelist_true.render(context)

            context.pop()

            return content

        elif self.nodelist_false:

            return self.nodelist_false.render(context)

        return ''

class IfEqualNode(Node):

    def __init__(self, var1, var2, nodelist_true, nodelist_false, negate):

        self.var1, self.var2 = Variable(var1), Variable(var2)

        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false

        self.negate = negate

    def __repr__(self):

        return "<IfEqualNode>"

    def render(self, context):

        try:

            val1 = self.var1.resolve(context)

        except VariableDoesNotExist:

            val1 = None

        try:

            val2 = self.var2.resolve(context)

        except VariableDoesNotExist:

            val2 = None

        if (self.negate and val1 != val2) or (not self.negate and val1 == val2):

            return self.nodelist_true.render(context)

        return self.nodelist_false.render(context)

class IfNode(Node):

    def __init__(self, bool_exprs, nodelist_true, nodelist_false, link_type):

        self.bool_exprs = bool_exprs

        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false

        self.link_type = link_type

    def __repr__(self):

        return "<If node>"

    def __iter__(self):

        for node in self.nodelist_true:

            yield node

        for node in self.nodelist_false:

            yield node

    def get_nodes_by_type(self, nodetype):

        nodes = []

        if isinstance(self, nodetype):

            nodes.append(self)

        nodes.extend(self.nodelist_true.get_nodes_by_type(nodetype))

        nodes.extend(self.nodelist_false.get_nodes_by_type(nodetype))

        return nodes

    def render(self, context):

        if self.link_type == IfNode.LinkTypes.or_:

            for ifnot, bool_expr in self.bool_exprs:

                try:

                    value = bool_expr.resolve(context, True)

                except VariableDoesNotExist:

                    value = None

                if (value and not ifnot) or (ifnot and not value):

                    return self.nodelist_true.render(context)

            return self.nodelist_false.render(context)

        else:

            for ifnot, bool_expr in self.bool_exprs:

                try:

                    value = bool_expr.resolve(context, True)

                except VariableDoesNotExist:

                    value = None

                if not ((value and not ifnot) or (ifnot and not value)):

                    return self.nodelist_false.render(context)

            return self.nodelist_true.render(context)

    class LinkTypes:

        and_ = 0,

        or_ = 1

class RegroupNode(Node):

    def __init__(self, target, expression, var_name):

        self.target, self.expression = target, expression

        self.var_name = var_name

    def render(self, context):

        obj_list = self.target.resolve(context, True)

        if obj_list == None:

            # target variable wasn't found in context; fail silently.

            context[self.var_name] = []

            return ''

        # List of dictionaries in the format:

        # {'grouper': 'key', 'list': [list of contents]}.

        context[self.var_name] = [

            {'grouper': key, 'list': list(val)}

            for key, val in

            groupby(obj_list, lambda v, f=self.expression.resolve: f(v, True))

        ]

        return ''

def include_is_allowed(filepath):

    for root in settings.ALLOWED_INCLUDE_ROOTS:

        if filepath.startswith(root):

            return True

    return False

class SsiNode(Node):

    def __init__(self, filepath, parsed):

        self.filepath, self.parsed = filepath, parsed

    def render(self, context):

        if not include_is_allowed(self.filepath):

            if settings.DEBUG:

                return "[Didn't have permission to include file]"

            else:

                return '' # Fail silently for invalid includes.

        try:

            fp = open(self.filepath, 'r')

            output = fp.read()

            fp.close()

        except IOError:

            output = ''

        if self.parsed:

            try:

                t = Template(output, name=self.filepath)

                return t.render(context)

            except TemplateSyntaxError, e:

                if settings.DEBUG:

                    return "[Included template had syntax error: %s]" % e

                else:

                    return '' # Fail silently for invalid included templates.

        return output

class LoadNode(Node):

    def render(self, context):

        return ''

class NowNode(Node):

    def __init__(self, format_string):

        self.format_string = format_string

    def render(self, context):

        from datetime import datetime

        from django.utils.dateformat import DateFormat

        df = DateFormat(datetime.now())

        return df.format(self.format_string)

class SpacelessNode(Node):

    def __init__(self, nodelist):

        self.nodelist = nodelist

    def render(self, context):

        from django.utils.html import strip_spaces_between_tags

        return strip_spaces_between_tags(self.nodelist.render(context).strip())

class TemplateTagNode(Node):

    mapping = {'openblock': BLOCK_TAG_START,

               'closeblock': BLOCK_TAG_END,

               'openvariable': VARIABLE_TAG_START,

               'closevariable': VARIABLE_TAG_END,

               'openbrace': SINGLE_BRACE_START,

               'closebrace': SINGLE_BRACE_END,

               'opencomment': COMMENT_TAG_START,

               'closecomment': COMMENT_TAG_END,

               }

    def __init__(self, tagtype):

        self.tagtype = tagtype

    def render(self, context):

        return self.mapping.get(self.tagtype, '')

class URLNode(Node):

    def __init__(self, view_name, args, kwargs, asvar):

        self.view_name = view_name

        self.args = args

        self.kwargs = kwargs

        self.asvar = asvar

    def render(self, context):

        from django.core.urlresolvers import reverse, NoReverseMatch

        args = [arg.resolve(context) for arg in self.args]

        kwargs = dict([(smart_str(k,'ascii'), v.resolve(context))

                       for k, v in self.kwargs.items()])

        # Try to look up the URL twice: once given the view name, and again

        # relative to what we guess is the "main" app. If they both fail, 

        # re-raise the NoReverseMatch unless we're using the 

        # {% url ... as var %} construct in which cause return nothing.

        url = ''

        try:

            url = reverse(self.view_name, args=args, kwargs=kwargs)

        except NoReverseMatch:

            project_name = settings.SETTINGS_MODULE.split('.')[0]

            try:

                url = reverse(project_name + '.' + self.view_name,

                              args=args, kwargs=kwargs)

            except NoReverseMatch:

                if self.asvar is None:

                    raise

        if self.asvar:

            context[self.asvar] = url

            return ''

        else:

            return url

class WidthRatioNode(Node):

    def __init__(self, val_expr, max_expr, max_width):

        self.val_expr = val_expr

        self.max_expr = max_expr

        self.max_width = max_width

    def render(self, context):

        try:

            value = self.val_expr.resolve(context)

            maxvalue = self.max_expr.resolve(context)

        except VariableDoesNotExist:

            return ''

        try:

            value = float(value)

            maxvalue = float(maxvalue)

            ratio = (value / maxvalue) * int(self.max_width)

        except (ValueError, ZeroDivisionError):

            return ''

        return str(int(round(ratio)))

class WithNode(Node):

    def __init__(self, var, name, nodelist):

        self.var = var

        self.name = name

        self.nodelist = nodelist

    def __repr__(self):

        return "<WithNode>"

    def render(self, context):

        val = self.var.resolve(context)

        context.push()

        context[self.name] = val

        output = self.nodelist.render(context)

        context.pop()

        return output

#@register.tag

def autoescape(parser, token):

    """

    Force autoescape behaviour for this block.

    """

    args = token.contents.split()

    if len(args) != 2:

        raise TemplateSyntaxError("'Autoescape' tag requires exactly one argument.")

    arg = args[1]

    if arg not in (u'on', u'off'):

        raise TemplateSyntaxError("'Autoescape' argument should be 'on' or 'off'")

    nodelist = parser.parse(('endautoescape',))

    parser.delete_first_token()

    return AutoEscapeControlNode((arg == 'on'), nodelist)

autoescape = register.tag(autoescape)

#@register.tag

def comment(parser, token):

    """

    Ignores everything between ``{% comment %}`` and ``{% endcomment %}``.

    """

    parser.skip_past('endcomment')

    return CommentNode()

comment = register.tag(comment)

#@register.tag

def cycle(parser, token):

    """

    Cycles among the given strings each time this tag is encountered.

    Within a loop, cycles among the given strings each time through

    the loop::

        {% for o in some_list %}

            <tr class="{% cycle 'row1' 'row2' %}">

                ...

            </tr>

        {% endfor %}

    Outside of a loop, give the values a unique name the first time you call

    it, then use that name each sucessive time through::

            <tr class="{% cycle 'row1' 'row2' 'row3' as rowcolors %}">...</tr>

            <tr class="{% cycle rowcolors %}">...</tr>

            <tr class="{% cycle rowcolors %}">...</tr>

    You can use any number of values, separated by spaces. Commas can also

    be used to separate values; if a comma is used, the cycle values are

    interpreted as literal strings.

    """

    # Note: This returns the exact same node on each {% cycle name %} call;

    # that is, the node object returned from {% cycle a b c as name %} and the

    # one returned from {% cycle name %} are the exact same object. This

    # shouldn't cause problems (heh), but if it does, now you know.

    #

    # Ugly hack warning: This stuffs the named template dict into parser so

    # that names are only unique within each template (as opposed to using

    # a global variable, which would make cycle names have to be unique across

    # *all* templates.

    args = token.split_contents()

    if len(args) < 2:

        raise TemplateSyntaxError("'cycle' tag requires at least two arguments")

    if ',' in args[1]:

        # Backwards compatibility: {% cycle a,b %} or {% cycle a,b as foo %}

        # case.

        args[1:2] = ['"%s"' % arg for arg in args[1].split(",")]

    if len(args) == 2:

        # {% cycle foo %} case.

        name = args[1]

        if not hasattr(parser, '_namedCycleNodes'):

            raise TemplateSyntaxError("No named cycles in template. '%s' is not defined" % name)

        if not name in parser._namedCycleNodes:

            raise TemplateSyntaxError("Named cycle '%s' does not exist" % name)

        return parser._namedCycleNodes[name]

    if len(args) > 4 and args[-2] == 'as':

        name = args[-1]

        node = CycleNode(args[1:-2], name)

        if not hasattr(parser, '_namedCycleNodes'):

            parser._namedCycleNodes = {}

        parser._namedCycleNodes[name] = node

    else:

        node = CycleNode(args[1:])

    return node

cycle = register.tag(cycle)

def debug(parser, token):

    """

    Outputs a whole load of debugging information, including the current

    context and imported modules.

    Sample usage::