#!/usr/bin/env python
# -*- coding: utf-8 -*-

from datetime import date, timedelta

from logging import getLogger

from django import template
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.template import defaultfilters
from django.utils.translation import ugettext as _
from django.template.loader import render_to_string

from chimere.models import Marker, Area, News, SubCategory, MultimediaType, \
    AreaOverlays
from chimere.version import get_version
from chimere.widgets import get_map_layers

log = getLogger(__name__)

register = template.Library()


@register.inclusion_tag('chimere/blocks/areas.html', takes_context=True)
def display_areas(context):
    """
    Display available areas.
    """
    context_data = {"areas": Area.getAvailable(),
                    "base_url": reverse(settings.MAIN_INDEX)
                    }
    if "area_name" in context:
        context_data['area_name'] = context["area_name"]
    return context_data


@register.inclusion_tag('chimere/blocks/submited.html', takes_context=True)
def submited(context):
    """
    Submited message.
    """
    return {"edit_url": reverse('chimere:edit'),
            "index_url": reverse(settings.MAIN_INDEX),
            'contact_email':
            settings.CONTACT_EMAIL if hasattr(settings, 'CONTACT_EMAIL')
            else None}


def get_news(area=None):
    # Retrieve news
    news = News.objects.filter(available=True, is_front_page=True)
    if area:
        news = news.filter(Q(areas__isnull=True) | Q(areas__in=[area.pk]))
    news = list(news.all())
    if settings.CHIMERE_DAYS_BEFORE_EVENT:
        # Retrieve active markers
        today = date.today()
        after = today + timedelta(settings.CHIMERE_DAYS_BEFORE_EVENT)
        q = Marker.objects.filter(
            status='A', start_date__lte=after).filter(
                Q(end_date__gte=today) |
                (Q(end_date__isnull=True) & Q(start_date__gte=today)))

        if 'CHIMERE_ALL_DATED_ARE_FRONT' not in dir(settings)\
           or not settings.CHIMERE_ALL_DATED_ARE_FRONT:
            q = q.filter(is_front_page=True)
        if area:
            q = q.filter(area.getIncludeMarker())
        news += list(q)
    news.sort(key=lambda x: x.date)
    return news


@register.inclusion_tag('chimere/blocks/welcome.html', takes_context=True)
def display_welcome(context, display=False, title=''):
    """
    Welcome message and active news.
    """
    context_data = {'display': display}
    area = None
    if "area_name" in context:
        try:
            area = Area.objects.get(urn=context["area_name"])
            context_data['area_name'] = context['area_name']
            context_data['welcome_message'] = area.welcome_message
        except ObjectDoesNotExist:
            pass
    else:
        try:
            area = Area.objects.get(default=True)
            context_data['area_name'] = context['area_name']
            context_data['welcome_message'] = area.welcome_message
        except ObjectDoesNotExist:
            pass
    context_data['news_lst'] = get_news(area)[:3]
    context_data['STATIC_URL'] = settings.STATIC_URL
    context_data['title'] = title if title \
        else _(u"Welcome to the %s") % settings.PROJECT_NAME
    return context_data


@register.inclusion_tag('chimere/blocks/news.html', takes_context=True)
def display_news(context, title=''):
    """
    All news.
    """
    area = None
    context_data = {'STATIC_URL': settings.STATIC_URL}
    if "area_name" in context:
        try:
            area = Area.objects.get(urn=context["area_name"])
            context_data['area_name'] = context['area_name']
            context_data['welcome_message'] = area.welcome_message
        except ObjectDoesNotExist:
            pass
    context_data['news_lst'] = get_news(area)
    return context_data


@register.inclusion_tag('chimere/blocks/head_jquery.html', takes_context=True)
def head_jquery(context):
    """
    Create context and display head elements (js, css, etc.) for jquery.
    """
    context_data = {
        "VERSION": get_version()
    }
    return context_data


@register.inclusion_tag('chimere/blocks/head_jme.html', takes_context=True)
def head_jme(context):
    """
    Create context and display head elements (js, css, etc.) for jme.
    """
    context_data = {"STATIC_URL": settings.STATIC_URL,
                    "VERSION": get_version()}
    return context_data


@register.inclusion_tag('chimere/blocks/head_chimere.html', takes_context=True)
def head_chimere(context):
    """
    Create context and display head elements (js, css, etc.) for chimere.
    """
    area_name = context['area_name'] if 'area_name' in context else 'area_name'
    area = None
    if area_name:
        try:
            area = Area.objects.get(urn=area_name)
        except ObjectDoesNotExist:
            pass
    action_selected = context.get('action_selected', None)
    is_edit = action_selected and action_selected[0] == "contribute"
    context_data = {
        "is_edit": is_edit,
        "LANGUAGE": settings.LANGUAGE_CODE.split('-')[0]
        if settings.LANGUAGE_CODE else 'en',
        "STATIC_URL": settings.STATIC_URL,
        "MEDIA_URL": settings.MEDIA_URL,
        "VERSION": get_version(),
        "DYNAMIC_CATEGORIES": 'true' if area and area.dynamic_categories
                              else 'false',
        "EXTRA_URL": reverse(settings.MAIN_INDEX),
        "EPSG_DISPLAY_PROJECTION": settings.CHIMERE_EPSG_DISPLAY_PROJECTION,
        "EPSG_PROJECTION": settings.CHIMERE_EPSG_PROJECTION,
        "DEFAULT_CENTER": settings.CHIMERE_DEFAULT_CENTER,
        "DEFAULT_ZOOM": settings.CHIMERE_DEFAULT_ZOOM,
        "MAP_LAYER": settings.CHIMERE_DEFAULT_MAP_LAYER,
        'MOBILE': context['MOBILE'],
        'routing':
            settings.CHIMERE_ENABLE_ROUTING
            if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
        'enable_clustering': settings.CHIMERE_ENABLE_CLUSTERING,
    }
    return context_data


@register.inclusion_tag('chimere/blocks/head_form.html')
def head_form():
    """
    Manualy add forms header (necessary in case of ajax load)
    """
    context_data = {"ENABLE_TINYMCE": settings.ENABLE_TINYMCE,
                    "STATIC_URL": settings.STATIC_URL,
                    "VERSION": get_version()}
    return context_data


@register.inclusion_tag('chimere/blocks/map_menu.html', takes_context=True)
def map_menu(context):
    context_data = {
        'routing': settings.CHIMERE_ENABLE_ROUTING
        if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
        'simple': context.get('simple')}
    return context_data


@register.inclusion_tag('chimere/blocks/routing.html', takes_context=True)
def routing(context):
    if not hasattr(settings, 'CHIMERE_ENABLE_ROUTING') or \
       not settings.CHIMERE_ENABLE_ROUTING:
        return {'routing': False}
    context_data = {
        'routing': settings.CHIMERE_ENABLE_ROUTING,
        'itinerary_form': context['itinerary_form'],
        'routing_fail_message':
        _(settings.CHIMERE_ROUTING_FAIL_MESSAGE).replace('\n', '\\n'),
        'routing_transport': context['routing_transport']}
    context_data['STATIC_URL'] = settings.STATIC_URL
    return context_data


@register.inclusion_tag('chimere/blocks/map.html', takes_context=True)
def map(context, map_id='map'):
    context_data = {
        'map_id': map_id,
        "STATIC_URL": settings.STATIC_URL,
        "enable_clustering": settings.CHIMERE_ENABLE_CLUSTERING,
        "popupContentFull": settings.CHIMERE_CONTENT_INSIDE_POPUP
    }
    context_data['MOBILE'] = context['MOBILE']
    context_data['routing'] = 'true' \
        if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') and \
        settings.CHIMERE_ENABLE_ROUTING \
        else 'false'
    area_name = context['area_name'] if 'area_name' in context else 'area_name'
    map_layers, default_area = get_map_layers(area_name)
    context_data['extra_js'] = u'\n'.join([
        extra_js for n, js, default, extra_js in map_layers if extra_js])
    context_data['js_map_layers'] = ", ".join(
        [js for name, js, default, extra_js in map_layers
         if "OpenLayers" not in js])
    context_data['map_layers'] = map_layers
    if default_area:
        context_data['selected_map_layer'] = default_area
    context_data['checked_categories'] = []
    area = None
    if area_name:
        try:
            area = Area.objects.get(urn=area_name)
        except ObjectDoesNotExist:
            pass
    if not area:
        try:
            area = Area.objects.get(default=True)
        except ObjectDoesNotExist:
            pass
    subcat_layer = SubCategory.objects.filter(as_layer=True, available=True)
    if area:
        context_data['json_overlays'] = [
            area_overlay.overlay for area_overlay in
            AreaOverlays.objects.filter(
                area=area, overlay__overlay_type='JSON').all()
        ]
        if area.subcategories.count():
            subcat_layer = subcat_layer.filter(areas__pk=area.pk)
        context_data['area_id'] = area_name
        if 'zoomout' in context and context['zoomout']:
            context_data['zoom'] = "[%s]" % ",".join(area.getExtent())
        context_data['display_category_menu'] = area.display_category_menu
        q_checked = None
        if not area.display_category_menu:
            if area.default_subcategories.count():
                q_checked = area.default_subcategories
            elif area.subcategories.count():
                q_checked = area.subcategories
            else:
                q_checked = SubCategory.objects
        elif area.default_subcategories.count():
            q_checked = area.default_subcategories
        if q_checked:
            context_data['checked_categories'] = [
                s.pk for s in q_checked.filter(available=True).all()]
        if area.restrict_to_extent:
            min_x = min(area.upper_left_corner.x, area.lower_right_corner.x)
            max_x = max(area.upper_left_corner.x, area.lower_right_corner.x)
            min_y = min(area.upper_left_corner.y, area.lower_right_corner.y)
            max_y = max(area.upper_left_corner.y, area.lower_right_corner.y)
            context_data['restricted_extent'] = \
                "var bounds = [{}, {}, {}, {}];\n".format(
                    min_x, min_y, max_x, max_y)
        context_data['extra_map_def'] = area.extra_map_def or ''
        if area.min_zoom:
            context_data['min_zoom'] = area.min_zoom
        if area.max_zoom:
            context_data['max_zoom'] = area.max_zoom

    context_data['subcat_layer'], c_cat = [], None
    for subcat in subcat_layer.order_by('category__order', 'category').all():
        if subcat.category != c_cat:
            context_data['subcat_layer'].append(subcat.category)
            c_cat = subcat.category
        context_data['subcat_layer'].append(subcat)
    if SubCategory.objects.filter(available=True).count() <= 1:
        if not context_data['checked_categories']:
            cat = ''
            if SubCategory.objects.filter(available=True).count():
                cat = str(SubCategory.objects.filter(
                    available=True).all()[0].pk)
            context_data['checked_categories'] = cat
    context_data['dynamic_categories'] = \
        'true' if area and area.dynamic_categories else 'false'
    if settings.CHIMERE_ROUTING_TRANSPORT:
        context_data['p_routing_transport'] = \
            settings.CHIMERE_ROUTING_TRANSPORT[0][0]
        if settings.CHIMERE_ROUTING_SPEEDS and \
           context_data['p_routing_transport'] \
           in settings.CHIMERE_ROUTING_SPEEDS:
            context_data['p_routing_speed'] = \
                settings.CHIMERE_ROUTING_SPEEDS[
                    context_data['p_routing_transport']][0][0]
    if 'request' not in context:
        return context_data
    request = context['request']
    # Default values
    context_data['p_current_route'] = context.get('current_route')
    if request.GET:
        for key in ('zoom', 'lon', 'lat', 'display_submited',
                    'current_feature', 'routing_start_lon',
                    'routing_start_lat', 'routing_end_lon', 'routing_end_lat',
                    'routing_steps', 'routing_transport', 'routing_speed'):
            p_key = 'p_' + key
            if key in request.GET and request.GET[key]:
                context_data[p_key] = request.GET[key]
            elif p_key not in context_data:
                context_data['p_' + key] = None
        if 'checked_categories' in request.GET \
           and request.GET['checked_categories']:
            cats = request.GET['checked_categories'].split('_')
            context_data['checked_categories'] = cats
    return context_data


@register.inclusion_tag('chimere/blocks/multimedia_file.html',
                        takes_context=True)
def multimedia_render(context, multimedia_file):
    context['multimedia_item'] = multimedia_file
    return context


@register.inclusion_tag('chimere/blocks/alternate_multimedia.html')
def alternate_multimedia(formset_multi, formset_picture):
    return {'formsets': [formset_multi, formset_picture],
            "STATIC_URL": settings.STATIC_URL,
            'auto_type_id': MultimediaType.objects.get(name='auto').pk}


@register.simple_tag
def get_tinyfied_url(marker, area_name=''):
    if not marker or not hasattr(marker, 'get_absolute_url'):
        return ""
    url = marker.get_absolute_url(area_name)
    return url


@register.inclusion_tag('chimere/blocks/share_bar.html',
                        takes_context=True)
def share_bar(context, name='', email_only=False, rss=True):
    context['STATIC_URL'] = settings.STATIC_URL
    context['name'] = name
    context['rss'] = rss
    context['email_only'] = email_only
    context['share_networks'] = [
        (defaultfilters.slugify(nme), url, icon)
        for nme, url, icon in settings.CHIMERE_SHARE_NETWORKS]
    return context


@register.filter(name='ol_map')
def ol_map(item, arg='map_id'):
    geom = None
    if hasattr(item, 'point'):
        geom = item.point
    elif hasattr(item, 'route'):
        geom = item.route
    elif hasattr(item, 'polygon'):
        geom = item.polygon
    rendered = render_to_string('chimere/blocks/ol_map.html', {'geom': geom,
                                                               'map_id': arg})
    return rendered