# Import Django's template library.
from django import template
# Import for determining the active URL.
from django.core import urlresolvers

# Get an instance of Django's template library.
register = template.Library()


@register.inclusion_tag('conntrackt/html_link.html')
def html_link(text, view, *args, **kwargs):
    """
    A small wrapper for showing HTML links.

    Positional arguments:

        text - Text that should be used as a link.

        view - View name for which the URL should be shown

        args - Additional positional arguments that will be passed to resolver
        for creating the URL.

    Keyword arguments:

        id - Identifier for the <a> HTML element.

        class - Class(es) for the <a> HTML element.

        title - Title for the HTML <a> element.

        get - Additional GET parameter that should be appended to the URL.

    """

    # We'll return a context for rendering with the template. Add the text right
    # away.
    context = {'text': text}

    # Generate the URL by using the supplied view name and arguments that should
    # be passed to the view.
    context['url'] = urlresolvers.reverse(view, args=args)

    # Iterate over keyword arguments, and if we support them, just assign them
    # to the context as is. Raise an exception if a keyword is unsupported.
    for key, value in kwargs.items():
        if key in ("class", "title", "id", "get"):
            context[key] = value
        else:
            raise template.TemplateSyntaxError("Unknown argument for 'advhtml_link' tag: %r" % key )

    return context


@register.simple_tag
def iptables(communication):
    """
    Produces an iptables rule based on the provided models.Communication object
    instance. The rule is appropriate for inclusion in the INPUT section of a
    file provided to the iptables-restore command.

    Arguments:

        communication - Instance of a models.Communication object.
    """
    values = (communication.source.address, communication.source.netmask, communication.protocol.lower(), communication.protocol.lower(), communication.port)
    if communication.protocol in ('TCP', 'UDP'):
        rule_template = "-A INPUT -s %s/%s -p %s -m %s --dport %s -j ACCEPT"
    elif communication.protocol in ('ICMP'):
        rule_template = "-A INPUT -s %s/%s -p %s -m %s --icmp-type %s -j ACCEPT"

    return rule_template % values


@register.simple_tag(takes_context = True)
def active_link(context, url_name, return_value='active', **kwargs):
    """
    This template tag can be used to check if the provided URL matches against
    the path from the request or not.

    Arguments:

      context - Context of the current view being called.

      url_name - Name of the URL that's being checked against current path from
      request.
    """

    matches = current_url_equals(context, url_name, **kwargs)

    return return_value if matches else ''
 
 
def current_url_equals(context, url_name, **kwargs):
    """
    Helper function for checking if the specified URL corresponds to the current
    request path in the context.

    Arguments:

      - context - Context of the view being rendered.

      - url_name - Name of the URL against which the context request path is
      being checked.
    """

    # Assume that we have not been able to resolve the request path to an URL.
    resolved = False
    try:
        # Use the request path, and resolve it to a URL name.
        resolved = urlresolvers.resolve(context.get('request').path)
    except urlresolvers.Resolver404:
        # This means we haven't been able to resolve the path from request.
        pass

    # If the request was resolved and URL names match, verify that the kwargs
    # match as well.
    matches = resolved and resolved.url_name == url_name
    if matches and kwargs:
        for key in kwargs:
            kwarg = kwargs.get(key)
            resolved_kwarg = resolved.kwargs.get(key)
            if not resolved_kwarg or kwarg != resolved_kwarg:
                return False

    return matches