from django import VERSION
from django import template
if VERSION[:2] >= (1, 10):
    from django.urls import reverse
    from django.core.urlresolvers import reverse
from django.utils.translation import ugettext_lazy as _
from waliki.acl import check_perms as check_perms_helper
from waliki.models import Page
from waliki.forms import PageForm
from waliki import settings

register = template.Library()

def extra_page_actions(page):
    from waliki.plugins import get_extra_page_actions
    return {'page': page, 'extra_page_actions': get_extra_page_actions()}

def extra_edit_actions(page):
    from waliki.plugins import get_extra_edit_actions
    return {'page': page, 'extra_edit_actions': get_extra_edit_actions()}

@register.inclusion_tag('waliki/entry_point.html', takes_context=True)
def entry_point(context, block_name):
    """include an snippet at the bottom of a block, if it exists

    For example, if the plugin with slug 'attachments' is registered

       waliki/attachments_edit_content.html  will be included with

        {% entry_point 'edit_content' %}

    which is declared at the bottom of the block 'content' in edit.html
    from waliki.plugins import get_plugins
    includes = []
    for plugin in get_plugins():
        template_name = 'waliki/%s_%s.html' % (plugin.slug, block_name)
            # template exists
        except template.TemplateDoesNotExist:
    context.update({'includes': includes})
    return context

def navbar_links():
    from waliki.plugins import get_navbar_links
    return {'navbar_links': get_navbar_links()}

def get_attr(obj, val):
        return getattr(obj, val)
    except AttributeError:
            return obj[val]
        except (KeyError, TypeError):
            return None

class CheckPermissionsNode(template.Node):

    def __init__(self, perms, user, slug, context_var):
        self.perms = template.Variable(perms)
        self.user = template.Variable(user)
        self.slug = template.Variable(slug)
        self.context_var = context_var

    def render(self, context):
        perms = [perm.strip() for perm in self.perms.literal.split(',')]
        user = self.user.resolve(context)
        slug = self.slug.literal or self.slug.resolve(context)
        if slug:
            context[self.context_var] = check_perms_helper(perms, user, slug)
            context[self.context_var] = False
        return ''

def check_perms(parser, token):
    Returns a list of permissions (as ``codename`` strings) for a given
    ``user``/``group`` and ``obj`` (Model instance).

    Parses ``check_perms`` tag which should be in format::

        {% check_perms "perm1[, perm2, ...]" for user in slug as "context_var" %}


        {% check_perms "perm1[, perm2, ...]" for user in "slug" as "context_var" %}

    .. note::

       Make sure that you set and use those permissions in same template
       block (``{% block %}``).

    Example of usage (assuming ``page` objects are available from *context*)::

        {% check_perms "delete_page" for request.user in page.slug as "can_delete" %}
        {% if can_delete %}
        {% endif %}

    bits = token.split_contents()
    format = '{% check_perms "perm1[, perm2, ...]" for user in slug as "context_var" %}'
    if len(bits) != 8 or bits[2] != 'for' or bits[4] != "in" or bits[6] != 'as':
        raise template.TemplateSyntaxError("get_obj_perms tag should be in "
                                           "format: %s" % format)
    perms = bits[1]
    user = bits[3]
    slug = bits[5]
    context_var = bits[7]
    if perms[0] != perms[-1] or perms[0] not in ('"', "'"):
        raise template.TemplateSyntaxError("check_perms tag's perms "
                                           "argument should be in quotes")

    if context_var[0] != context_var[-1] or context_var[0] not in ('"', "'"):
        raise template.TemplateSyntaxError("check_perms tag's context_var "
                                           "argument should be in quotes")
    context_var = context_var[1:-1]
    return CheckPermissionsNode(perms, user, slug, context_var)

@register.inclusion_tag("waliki/box.html", takes_context=True)
def waliki_box(context, slug, show_edit=True, *args, **kwargs):
    A templatetag to render a wiki page content as a box in any webpage,
    and allow rapid edition if you have permission.

    It's inspired in `django-boxes`_

    .. _django-boxes:

    request = context["request"]
        page = Page.objects.get(slug=slug)
    except Page.DoesNotExist:
        page = None

    if (page and check_perms_helper('change_page', request.user, slug)
            or (not page and check_perms_helper('add_page', request.user, slug))):
        form = PageForm(instance=page, initial={'slug': slug})
        form_action = reverse("waliki_edit", args=[slug])
        form = None
        form_action = None

    return {
        "request": request,
        "slug": slug,
        "label": slug.replace('/', '_'),
        "page": page,
        "form": form,
        "form_action": form_action,

def waliki_breadcrumbs(slug):
    if not settings.WALIKI_BREADCRUMBS:
        return None
    breadcrumbs = [(reverse('waliki_home'), _('Home')),]
    if slug == settings.WALIKI_INDEX_SLUG:
        return breadcrumbs
    slug_parts = slug.split('/')
    url = ''
    # for every string from start until the next slash (or end of string)
    for part in slug_parts:
        # if page exists, find url and title
        # otherwise, grab url and title from slug
        url = url + part
        pages = Page.objects.filter(slug=url)
        url = url + '/'
        if pages:
            title = pages[0].title
           title = part
        breadcrumbs.append(('/'+url, title))
    return breadcrumbs