# -*- coding: utf-8 -*-
from django.shortcuts import  render_to_response
from django.http import HttpResponseRedirect, HttpResponse, Http404
from django.contrib.contenttypes.models import ContentType
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.contrib.admin.views.decorators import staff_member_required
from file.models import TmpFile, FileModel
from file.forms import FileModelForm, FileForm
from city.models import City
from theme.models import Tag
from article.models import Article
from django.db.models.loading import get_model



def admin_home(request):
    return render_to_response('base.html')

def ajax_city(request):
    """
    returns html <option> tags filled with cities filtered by country value from request
    """
    objects = City.objects.language().filter(country=request.GET['id']).order_by('name')
    return render_to_response('select.html', {'objects': objects})

def ajax_tag(request):
    """

    return array of tags (id, name) filtered by theme values from request

    """
    if request.GET:
        ids = request.GET.get('id')
        if ids:
            #get id values in list
            data = ids.replace('theme=', '').split('&')
            #generate list of tags
            tags = ['[%d, "%s"]'%(int(item.id), item.name) for item in Tag.objects.language().filter(theme__in=data).order_by('name')]
            return HttpResponse('[%s]'%', '.join(tags), content_type='application/json')
        else:
            #request empty - send empty array
            return HttpResponse('[]', content_type='application/json')


def get_news(request):
    """

    return array of tags (id, name) filtered by theme values from request

    """
    term = request.GET['term'].capitalize()
    if not term:
        qs = Article.objects.news()[:50]
    else:
        qs = Article.objects.news().filter(translations__main_title__contains=term)
    result = [{'id': item.id, 'label': item.main_title} for item in qs]

    return HttpResponse(json.dumps(result), content_type='application/json')


'''
def ajax_post_file(request, obj_id=None):
    """
    Takes file and file data and save it
    If obj_id = None creates TmpFile

    Returns 'file_list.html' template with existing files if id != None.
    N/A file_list.html' template with Tmp files filtered by key
    """
    if request.POST:
        file_form = FileModelForm(request.POST, request.FILES)
        if file_form.is_valid():
            #if obj_id is not exist create TMPfile objects else FileModel objects
            if obj_id != None:
                #takes data from hidden input "model" and initial Model
                Model = get_model(request.POST['model'].split('.')[0], request.POST['model'].split('.')[1])
                #initial model object
                obj = Model.objects.get(id=obj_id)
                file = file_form.save(request.FILES, obj)

                files = FileModel.objects.filter(content_type=ContentType.objects.get_for_model(obj),object_id=getattr(obj, 'id'))
            else:
                file_form.save(request.FILES)
                files = TmpFile.objects.filter(key=request.POST['key'])

            return render_to_response('file_list.html', {'files' : files})

    args = {}

    args['languages'] = settings.LANGUAGES
    args['file_form'] = file_form
    return render_to_response('ajax_error_form.html', args)
'''
from django.core.context_processors import csrf
def ajax_post_file(request, obj_id=None):
    """
    Takes file and file data and save it

    Returns 'file_list.html' template with existing files if id != None.

    """
    if request.POST:
        if not obj_id:
            raise Http404
        file_form = FileForm(request.POST, request.FILES)
        if file_form.is_valid():
            #takes data from hidden input "model" and initial Model
            Model = get_model(request.POST['model'].split('.')[0], request.POST['model'].split('.')[1])
            #initial model object
            obj = Model.objects.get(id=obj_id)
            file = file_form.save(request.FILES, obj)

            files = FileModel.objects.filter(content_type=ContentType.objects.get_for_model(obj),object_id=getattr(obj, 'id'))


            return render_to_response('file_list.html', {'files' : files})
        else:
            args = {}

            args['languages'] = settings.LANGUAGES
            args['file_form'] = file_form
            args['obj_id'] = obj_id
            args.update(csrf(request))
            return render_to_response('ajax_error_form.html', args)
    else:
        raise Http404



from file.forms import PhotoForm
from file.models import Photo

def ajax_post_photo(request, obj_id=None):
    if request.POST:
        photo_form = PhotoForm(request.POST, request.FILES)
        if photo_form.is_valid():

            if obj_id != None:
                Model = get_model(request.POST['model'].split('.')[0], request.POST['model'].split('.')[1])
                obj = Model.objects.get(id=obj_id)
                photo = photo_form.save(request.FILES, obj)
                photos = Photo.objects.filter(content_type=ContentType.objects.get_for_model(obj),object_id=getattr(obj, 'id'))
            else:
                photo_form.save(request.FILES)
                photos = TmpFile.objects.filter(key=request.POST['key'], purpose='photo')
            #return HttpResponse('123')
            return render_to_response('photo_list.html', {'photos': photos})

    args = {}

    args['languages'] = settings.LANGUAGES
    args['file_form'] = photo_form
    return render_to_response('ajax_error_form.html', args)

from exposition.models import Exposition, TimeTable, TmpTimeTable
from exposition.forms import TimeTableForm
import json, datetime
from functions import datetime_handler


def ajax_post_timetable(request, obj_id=None):
    if request.GET:
        form = TimeTableForm(request.GET)
        if form.is_valid():
            if obj_id:
                exp = Exposition.objects.safe_get(id=obj_id)
                form.save(exp)
                objects = TimeTable.objects.filter(exposition=exp)
            else:
                form.save()
                objects = TmpTimeTable.objects.filter(key=request.GET.get('key'))

            return render_to_response('timetable_list.html', {'objects': objects})

        else:
            return HttpResponse(json.dumps(form.errors), content_type='application/json')

    else:

        return HttpResponse('error')
from exposition.models import Statistic
from exposition.forms import StatisticForm
def ajax_post_stat(request, obj_id=None):
    response = {'success': False}
    if request.GET:
        form = StatisticForm(request.GET)
        if form.is_valid():

            exp = Exposition.objects.safe_get(id=obj_id)
            if exp:
                form.save(exp)
                response['success'] = True
        else:
            response.update({'errors': form.errors})

    return HttpResponse(json.dumps(response), content_type='application/json')

def ajax_delete_stat(request, id):
    redirect_to = request.META.get('HTTP_REFERER')


    if id:
        try:
            Statistic.objects.get(id=id).delete()
        except Statistic.DoesNotExist:
            pass


    return HttpResponseRedirect(redirect_to)




def ajax_delete_timetable(request):
    if request.GET:
        id = request.GET.get('id')
        if id:
            TimeTable.objects.get(id=id).delete()
            data = {'id': id}
        return HttpResponse(json.dumps(data), content_type='application/json')

    else:
        return HttpResponse('error')


def ajax_delete_file(request):
    """
    delete file
    """
    if request.GET:
        file = FileModel.objects.get(id = request.GET['id'])
        file.delete()
        return HttpResponse('success')
    else:
        return HttpResponse('error')