#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2010-2013  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# See the file COPYING for details.

try:
    import tidy
except:
    from tidylib import tidy_document as tidy

import re
import csv
import json
import datetime
import optparse
import cStringIO as StringIO
from tempfile import NamedTemporaryFile
import ho.pisa as pisa

from django.conf import settings
from django.contrib.auth import logout
from django.core import serializers
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse, NoReverseMatch
from django.db.models import Q
from django.http import HttpResponse, Http404
from django.shortcuts import render_to_response, redirect
from django.template import RequestContext, loader
from django.template.defaultfilters import slugify
from django.utils.translation import ugettext, ugettext_lazy as _

if settings.XHTML2ODT_PATH:
    import sys
    sys.path.append(settings.XHTML2ODT_PATH)
    from xhtml2odt import xhtml2odt

from menus import menu

from ishtar_common.forms import FinalForm
from ishtar_common.forms_common import PersonForm, PersonFormSelection,\
                     AccountForm, FinalAccountForm, OrganizationForm, AuthorForm
from ishtar_common.wizards import PersonWizard, PersonModifWizard, AccountWizard
import models

CSV_OPTIONS = {'delimiter':';', 'quotechar':'"', 'quoting':csv.QUOTE_ALL}
ENCODING = settings.ENCODING or 'utf-8'

def index(request):
    """
    Main page
    """
    dct = {}
    try:
        return render_to_response('index.html', dct,
                              context_instance=RequestContext(request))
    except NoReverseMatch:
        # probably rights exception (rights revoked)
        logout(request)
        return render_to_response('index.html', dct,
                              context_instance=RequestContext(request))

person_creation_wizard = PersonWizard.as_view([
                        ('identity-person_creation', PersonForm),
                        ('final-person_creation', FinalForm)],
                         label=_(u"New person"),
                         url_name='person_creation')

person_modification_wizard = PersonModifWizard.as_view([
                      ('selec-person_modification', PersonFormSelection),
                      ('identity-person_modification', PersonForm),
                      ('final-person_modification', FinalForm)],
                       label=_(u"Person modification"),
                       url_name='person_modification')

account_management_wizard = AccountWizard.as_view([
                    ('selec-account_management', PersonFormSelection),
                    ('account-account_management', AccountForm),
                    ('final-account_management', FinalAccountForm)],
                     label=_(u"Account management"),
                     url_name='account_management',)

def update_current_item(request):
    if not request.is_ajax() and not request.method == 'POST':
        raise Http404
    if 'value' in request.POST and 'item' in request.POST:
        request.session[request.POST['item']] = request.POST['value']
    return HttpResponse('ok')

def check_permission(request, action_slug, obj_id=None):
    if action_slug not in menu.items:
        #! TODO
        return True
    if obj_id:
        return menu.items[action_slug].is_available(request.user, obj_id)
    return menu.items[action_slug].can_be_available(request.user)

def autocomplete_person(request, person_type=None):
    person_types = request.user.ishtaruser.person.person_type
    if (not request.user.has_perm('ishtar_common.view_person', models.Person) and
       not request.user.has_perm('ishtar_common.view_own_person', models.Person)
       and not person_types.rights.filter(wizard__url_name='person_search'
                                                                     ).count()):
        return HttpResponse(mimetype='text/plain')
    if not request.GET.get('term'):
        return HttpResponse(mimetype='text/plain')
    q = request.GET.get('term')
    limit = request.GET.get('limit', 20)
    try:
        limit = int(limit)
    except ValueError:
        return HttpResponseBadRequest()
    query = Q()
    for q in q.split(' '):
        query = query & (Q(name__icontains=q) | Q(surname__icontains=q) | \
                         Q(email__icontains=q))
    if person_type:
        try:
            typs = [int(tp) for tp in person_type.split('_') if tp]
            typ = models.PersonType.objects.filter(pk__in=typs).all()
            query = query & Q(person_type__in=typ)
        except (ValueError, ObjectDoesNotExist):
            pass
    limit = 20
    persons = models.Person.objects.filter(query)[:limit]
    data = json.dumps([{'id':person.pk, 'value':unicode(person)}
                                for person in persons if person])
    return HttpResponse(data, mimetype='text/plain')

def autocomplete_town(request):
    if not request.GET.get('term'):
        return HttpResponse(mimetype='text/plain')
    q = request.GET.get('term')
    query = Q()
    for q in q.split(' '):
        extra = Q(name__icontains=q)
        if settings.COUNTRY == 'fr':
            extra = (extra | Q(numero_insee__istartswith=q) | \
                    Q(departement__label__istartswith=q))
        query = query & extra
    limit = 20
    towns = models.Town.objects.filter(query)[:limit]
    data = json.dumps([{'id':town.pk, 'value':unicode(town)}
                                          for town in towns])
    return HttpResponse(data, mimetype='text/plain')

from types import NoneType

def format_val(val):
    if type(val) == NoneType:
        return u""
    if type(val) == bool:
        if val:
            return unicode(_(u"True"))
        else:
            return unicode(_(u"False"))
    return unicode(val)

HIERARCHIC_LEVELS = 5
HIERARCHIC_FIELDS = ['periods', 'period', 'unit', 'material_type']
PRIVATE_FIELDS = ('id', 'history_modifier', 'order')
def get_item(model, func_name, default_name, extra_request_keys=[],
            base_request={}, bool_fields=[], dated_fields=[]):
    """
    Generic treatment of tables
    """
    def func(request, data_type='json', full=False, **dct):
        if 'type' in dct:
            data_type = dct.pop('type')
        if not data_type:
            data_type = 'json'
        fields = [model._meta.get_field_by_name(k)[0]
                  for k in model._meta.get_all_field_names()]
        request_keys = dict([(field.name,
            field.name + (hasattr(field, 'rel') and field.rel and '__pk' or ''))
                                for field in fields])
        request_keys.update(extra_request_keys)
        request_items = request.method == 'POST' and request.POST or request.GET
        dct = base_request.copy()
        try:
            old = 'old' in request_items and int(request_items['old'])
        except ValueError:
            return HttpResponse(None, mimetype='text/plain')
        for k in request_keys:
            q = request_items.get(k)
            if not q:
                continue
            dct[request_keys[k]] = q
        if not dct and 'submited' not in request_items:
            if default_name in request.session and \
               request.session[default_name]:
                dct = {"pk":request.session[default_name]}
            if (not dct or data_type == 'csv') and func_name in request.session:
                dct = request.session[func_name]
        else:
            request.session[func_name] = dct
        for k in bool_fields:
            if k in dct:
                if dct[k] == u"1":
                    dct.pop(k)
                else:
                    dct[k] = dct[k] == u"2" and True or False
        for k in dated_fields:
            if k in dct:
                if not dct[k]:
                    dct.pop(k)
                try:
                    items = dct[k].split('/')
                    assert len(items) == 3
                    dct[k] = datetime.date(*map(lambda x: int(x),
                                                reversed(items))
                                            ).strftime('%Y-%m-%d')
                except AssertionError:
                    dct.pop(k)
        # manage hierarchic conditions
        or_reqs = []
        for req in dct.copy():
            for k_hr in HIERARCHIC_FIELDS:
                if type(req) in (list, tuple):
                    val = dct.pop(req)
                    q = None
                    for idx, r in enumerate(req):
                        if not idx:
                            q = Q(**{r:val})
                        else:
                            q = q | Q(**{r:val})
                    or_reqs.append(q)
                    break
                elif req.endswith(k_hr + '__pk'):
                    val = dct.pop(req)
                    reqs = Q(**{req:val})
                    req = req[:-2] + '__'
                    for idx in xrange(HIERARCHIC_LEVELS):
                        req = req[:-2] + 'parent__pk'
                        q = Q(**{req:val})
                        reqs = reqs | q
                    or_reqs.append(reqs)
                    break
        query = Q(**dct)
        for or_req in or_reqs:
            query = query & or_req
        items = model.objects.filter(query).distinct()
        q = request_items.get('sidx')

        # manage sort tables
        if q and q in request_keys:
            ks = request_keys[q]
            if type(ks) not in (list, tuple):
                ks = [ks]
            orders = []
            for k in ks:
                if k.endswith("__pk"):
                    k = k[:-len("__pk")] + "__label"
                q = request_items.get('sord')
                sign = q and q == u'desc' and "-" or ''
                if '__' in k:
                    k = k.split('__')[0]
                orders.append(sign+k)
            items = items.order_by(*orders)

        # pager management
        start, end = 0, None
        page_nb = 1
        try:
            row_nb = int(request_items.get('rows'))
        except (ValueError, TypeError):
            row_nb = None
        if row_nb:
            try:
                page_nb = int(request_items.get('page'))
                assert page_nb >= 1
            except (ValueError, AssertionError):
                pass
            start = (page_nb-1)*row_nb
            end = page_nb*row_nb
        items_nb = items.count()
        items = items[start:end]

        datas = []
        if old:
            items = [item.get_previous(old) for item in items]
        table_cols = full and [field.name for field in model._meta.fields
                               if field.name not in PRIVATE_FIELDS] \
                     or model.TABLE_COLS
        for item in items:
            data = [item.pk]
            for k in table_cols:
                vals = [item]
                for ky in k.split('.'):
                    new_vals = []
                    for val in vals:
                        if hasattr(val, 'all'): # manage related objects
                            val = list(val.all())
                            for v in val:
                                new_vals.append(getattr(v, ky))
                        elif val:
                            new_vals.append(getattr(val, ky))
                    vals = new_vals
                if vals and hasattr(vals[0], 'all'): # manage last related objects
                    new_vals = []
                    for val in vals:
                        new_vals += list(val.all())
                    vals = new_vals
                data.append(", ".join([format_val(v) for v in vals]) or u"")
            datas.append(data)
        link_template = "<a href='#' onclick='load_window(\"%%s\")'>%s</a>" % \
                        (unicode(_("Details")))
        if data_type == "json":
            rows = []
            for data in datas:
                try:
                    lnk = link_template % reverse('show-'+default_name,
                                                      args=[data[0], ''])
                except NoReverseMatch:
                    lnk = ''
                res = {'id':data[0], 'link':lnk}
                for idx, value in enumerate(data[1:]):
                    if value:
                        res[table_cols[idx].split('.')[-1]] = value
                rows.append(res)
            data = json.dumps({
                "records":items_nb,
                "rows":rows,
                "page":page_nb,
                "total":items_nb/row_nb + 1,
            })
            return HttpResponse(data, mimetype='text/plain')
        elif data_type == "csv":
            response = HttpResponse(mimetype='text/csv')
            n = datetime.datetime.now()
            filename = u'%s_%s.csv' % (default_name,
                                       n.strftime('%Y%m%d-%H%M%S'))
            response['Content-Disposition'] = 'attachment; filename=%s'%filename
            writer = csv.writer(response, **CSV_OPTIONS)
            col_names = []
            for field_name in table_cols:
                try:
                    field = model._meta.get_field(field_name)
                except:
                    col_names.append(u"".encode(ENCODING))
                    continue
                col_names.append(unicode(field.verbose_name).encode(ENCODING))
            writer.writerow(col_names)
            for data in datas:
                writer.writerow([val.encode(ENCODING) for val in data[1:]])
            return response
        return HttpResponse(None, mimetype='text/plain')

    return func

def show_item(model, name):
    def func(request, pk, **dct):
        try:
            item = model.objects.get(pk=pk)
        except ObjectDoesNotExist:
            return HttpResponse(None)
        doc_type = 'type' in dct and dct.pop('type')
        date = 'date' in dct and dct.pop('date')
        dct['window_id'] = "%s-%d-%s" % (name, item.pk,
                                      datetime.datetime.now().strftime('%M%s'))
        if date:
            try:
                date = datetime.datetime.strptime(date, '%Y-%m-%dT%H:%M:%S.%f')
                item = item.get_previous(date=date)
                assert item != None
            except (ValueError, AssertionError):
                return HttpResponse(None, mimetype='text/plain')
            dct['previous'] = item._previous
            dct['next'] = item._next
        else:
            historized = item.history.all()
            if historized:
                item.history_date = historized[0].history_date
            if len(historized) > 1:
                dct['previous'] = historized[1].history_date
        dct['item'], dct['item_name'] = item, name
        context_instance = RequestContext(request)
        context_instance.update(dct)
        n = datetime.datetime.now()
        filename = u'%s_%s_%s' % (name, slugify(unicode(item)),
                                  n.strftime('%Y%m%d-%H%M%S'))
        if doc_type == "odt" and settings.XHTML2ODT_PATH and \
           settings.ODT_TEMPLATE:
            tpl = loader.get_template('ishtar/sheet_%s.html' % name)
            content = tpl.render(context_instance)
            try:
                tidy_options = dict(output_xhtml=1, add_xml_decl=1, indent=1,
                        tidy_mark=0, output_encoding='utf8', doctype='auto',
                        wrap=0, char_encoding='utf8')
                html = str(tidy.parseString(content.encode('utf-8'),
                                            **tidy_options))
                html = html.replace("&nbsp;", "&#160;")
                html = re.sub('<pre([^>]*)>\n', '<pre\\1>', html)

                odt = NamedTemporaryFile()
                options = optparse.Values()
                options.with_network = True
                for k, v in (('input', ''),
                             ('output', odt.name),
                             ('template', settings.ODT_TEMPLATE),
                             ('with_network', True),
                             ('top_header_level', 1),
                             ('img_width', '8cm'),
                             ('img_height', '6cm'),
                             ('verbose', False),
                             ('replace_keyword', 'ODT-INSERT'),
                             ('cut_start', 'ODT-CUT-START'),
                             ('htmlid', None),
                             ('url', "#")):
                    setattr(options, k, v)
                odtfile = xhtml2odt.ODTFile(options)
                odtfile.open()
                odtfile.import_xhtml(html)
                odtfile = odtfile.save()
            except xhtml2odt.ODTExportError, ex:
                return HttpResponse(content, content_type="application/xhtml")
            response = HttpResponse(
                            mimetype='application/vnd.oasis.opendocument.text')
            response['Content-Disposition'] = 'attachment; filename=%s.odt' % \
                                                                       filename
            response.write(odtfile)
            return response
        elif doc_type == 'pdf':
            tpl = loader.get_template('ishtar/sheet_%s_pdf.html' % name)
            content = tpl.render(context_instance)
            result = StringIO.StringIO()
            html = content.encode('utf-8')
            html = html.replace("<table", "<pdf:nextpage/><table repeat='1'")
            pdf = pisa.pisaDocument(StringIO.StringIO(html), result)
            response = HttpResponse(result.getvalue(),
                                    mimetype='application/pdf')
            response['Content-Disposition'] = 'attachment; filename=%s.pdf' % \
                                                                       filename
            if not pdf.err:
                return response
            return HttpResponse(content, content_type="application/xhtml")
        else:
            tpl = loader.get_template('ishtar/sheet_%s_window.html' % name)
            content = tpl.render(context_instance)
            return HttpResponse(content, content_type="application/xhtml")
    return func

def revert_item(model):
    def func(request, pk, date, **dct):
        try:
            item = model.objects.get(pk=pk)
            date = datetime.datetime.strptime(date, '%Y-%m-%dT%H:%M:%S.%f')
            item.rollback(date)
        except (ObjectDoesNotExist, ValueError, HistoryError):
            return HttpResponse(None, mimetype='text/plain')
        return HttpResponse("True", mimetype='text/plain')
    return func

def autocomplete_organization(request, orga_type=None):
    person_types = request.user.ishtaruser.person.person_type
    if (not request.user.has_perm('ishtar_common.view_organization',
                                 models.Organization) and \
       not request.user.has_perm('ishtar_common.view_own_organization',
                                 models.Organization)
       and not person_types.rights.filter(wizard__url_name='person_search'
                                                                     ).count()):
        return HttpResponse(mimetype='text/plain')
    if not request.GET.get('term'):
        return HttpResponse(mimetype='text/plain')
    q = request.GET.get('term')
    query = Q()
    for q in q.split(' '):
        extra = Q(name__icontains=q)
        query = query & extra
    if orga_type:
        try:
            typs = [int(tp) for tp in orga_type.split('_') if tp]
            typ = models.OrganizationType.objects.filter(pk__in=typs).all()
            query = query & Q(organization_type__in=typ)
        except (ValueError, ObjectDoesNotExist):
            pass
    limit = 15
    organizations = models.Organization.objects.filter(query)[:limit]
    data = json.dumps([{'id':org.pk, 'value':unicode(org)}
                                          for org in organizations])
    return HttpResponse(data, mimetype='text/plain')

def autocomplete_author(request):
    if not request.user.has_perm('ishtar_common.view_author', models.Author)\
       and not request.user.has_perm('ishtar_common.view_own_author',
                                     models.Author) :
        return HttpResponse(mimetype='text/plain')
    if not request.GET.get('term'):
        return HttpResponse(mimetype='text/plain')
    q = request.GET.get('term')
    query = Q()
    for q in q.split(' '):
        extra = Q(person__name__icontains=q) | \
                Q(person__surname__icontains=q) | \
                Q(person__email__icontains=q) | \
                Q(author_type__label__icontains=q)
        query = query & extra
    limit = 15
    authors = models.Author.objects.filter(query)[:limit]
    data = json.dumps([{'id':author.pk, 'value':unicode(author)}
                                          for author in authors])
    return HttpResponse(data, mimetype='text/plain')

def new_item(model, frm):
    def func(request, parent_name):
        model_name = model._meta.object_name
        if not check_permission(request, 'add_'+model_name.lower()):
            not_permitted_msg = ugettext(u"Operation not permitted.")
            return HttpResponse(not_permitted_msg)
        #frm = getattr(ishtar_forms, model_name + 'Form')
        dct = {'title':unicode(_(u'New %s' % model_name.lower()))}
        if request.method == 'POST':
            dct['form'] = frm(request.POST)
            if dct['form'].is_valid():
                new_item = dct['form'].save(request.user)
                dct['new_item_label'] = unicode(new_item)
                dct['new_item_pk'] = new_item.pk
                dct['parent_name'] = parent_name
                dct['parent_pk'] = parent_name
                if dct['parent_pk'] and '_select_' in dct['parent_pk']:
                    parents = dct['parent_pk'].split('_')
                    dct['parent_pk'] = "_".join([parents[0]] + parents[2:])
                return render_to_response('window.html', dct,
                                  context_instance=RequestContext(request))
        else:
            dct['form'] = frm()
        return render_to_response('window.html', dct,
                                  context_instance=RequestContext(request))
    return func

new_person = new_item(models.Person, PersonForm)
new_organization = new_item(models.Organization, OrganizationForm)
new_author = new_item(models.Author, AuthorForm)

def action(request, action_slug, obj_id=None, *args, **kwargs):
    """
    Action management
    """
    if not check_permission(request, action_slug, obj_id):
        not_permitted_msg = ugettext(u"Operation not permitted.")
        return HttpResponse(not_permitted_msg)
    request.session['CURRENT_ACTION'] = action_slug
    associated_wizard = action_slug + '_wizard'
    dct = {}
    globals_dct = globals()
    print action_slug
    if action_slug in globals_dct:
        return globals_dct[action_slug](request, dct, obj_id, *args, **kwargs)
    elif hasattr(ishtar_forms, action_slug + "_wizard"):
        return getattr(ishtar_forms, action_slug+"_wizard")(request, *args,
                                                            **kwargs)
    return render_to_response('index.html', dct,
                              context_instance=RequestContext(request))

def dashboard_main(request, dct, obj_id=None, *args, **kwargs):
    """
    Main dashboard
    """
    items = []
    if 'archaeological_files' in settings.INSTALLED_APPS:
        from archaeological_files.models import File
        items.append((_(u"Archaeological files"),
                     models.Dashboard(File)))
    from archaeological_operations.models import Operation
    items.append((_(u"Operations"), models.Dashboard(Operation)))
    if 'archaeological_context_records' in settings.INSTALLED_APPS:
        from archaeological_context_records.models import ContextRecord
        items.append((_(u"Context records"), models.Dashboard(ContextRecord)))
    if 'archaeological_finds' in settings.INSTALLED_APPS:
        from archaeological_finds.models import Find
        items.append((_(u"Context records"), models.Dashboard(Find)))
    dct = {'items':items,
           'ishtar_users':models.UserDashboard()}
    return render_to_response('ishtar/dashboards/dashboard_main.html', dct,
                               context_instance=RequestContext(request))