import re

from django import forms
from django.conf import settings
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from django.template import Context, loader

import databaseReset
from troggle.core.models import Expedition, Person, PersonExpedition
from troggle.core.models_caves import LogbookEntry, QM, Cave, PersonTrip
from troggle.helper import login_required_if_public


def showrequest(request):
    return HttpResponse(request.GET)

def stats(request):
    statsDict={}
    statsDict['expoCount'] = int(Expedition.objects.count())
    statsDict['caveCount'] = int(Cave.objects.count())
    statsDict['personCount'] = int(Person.objects.count())
    statsDict['logbookEntryCount'] = int(LogbookEntry.objects.count())
    return render(request,'statistics.html', statsDict)

def frontpage(request):
    if request.user.is_authenticated():
        return render(request,'tasks.html')

    expeditions =  Expedition.objects.order_by("-year")
    logbookentry = LogbookEntry
    cave = Cave
    #photo = DPhoto
    from django.contrib.admin.templatetags import log
    return render(request,'frontpage.html', locals())

def todo(request):
    message = "no test message"  #reverse('personn', kwargs={"name":"hkjhjh"}) 
    if "reloadexpos" in request.GET:
        message = LoadPersonsExpos()
        message = "Reloaded personexpos"
    if "reloadsurvex" in request.POST:
        message = LoadAllSurvexBlocks()
        message = "Reloaded survexblocks"

    expeditions =  Expedition.objects.order_by("-year")
    totallogbookentries = LogbookEntry.objects.count()
    return render(request,'index.html', {'expeditions':expeditions, 'all':'all', 'totallogbookentries':totallogbookentries, "message":message})


def controlPanel(request):
    jobs_completed=[]
    if request.method=='POST':
        if request.user.is_superuser:
    
            #importlist is mostly here so that things happen in the correct order.
            #http post data seems to come in an unpredictable order, so we do it this way.
            importlist=['reinit_db', 'import_people', 'import_caves', 'import_logbooks',
            'import_survexblks', 'import_QMs', 'import_survexpos', 'import_surveyscans', 'import_tunnelfiles']
            databaseReset.dirsredirect()
            for item in importlist:
                if item in request.POST:
                    print(("running"+ " databaseReset."+item+"()"))
                    exec("databaseReset."+item+"()")
                    jobs_completed.append(item)
        else:
            if request.user.is_authenticated(): #The user is logged in, but is not a superuser.
                return render(request,'controlPanel.html', {'caves':Cave.objects.all(),'error':'You must be a superuser to use that feature.'})
            else:
                return HttpResponseRedirect(reverse('auth_login'))

    return render(request,'controlPanel.html', {'caves':Cave.objects.all(),'expeditions':Expedition.objects.all(),'jobs_completed':jobs_completed})

def downloadSurveys(request):
    from export import tosurveys
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=Surveys.csv'
    return response

def downloadLogbook(request,year=None,extension=None,queryset=None):
    
    if year:
        current_expedition=Expedition.objects.get(year=year)
        logbook_entries=LogbookEntry.objects.filter(expedition=current_expedition)
        filename='logbook'+year
    elif queryset:
        logbook_entries=queryset
        filename='logbook'
    else:
        response = HttpResponse(content_type='text/plain')
        return response(r"Error: Logbook downloader doesn't know what year you want")
    
    if 'year' in request.GET:
        year=request.GET['year']
    if 'extension' in request.GET:
        extension=request.GET['extension']

    if extension =='txt':
        response = HttpResponse(content_type='text/plain')
        style='2008'
    elif extension == 'html':
        response = HttpResponse(content_type='text/html')
        style='2005'
        
    template='logbook'+style+'style.'+extension
    response['Content-Disposition'] = 'attachment; filename='+filename+'.'+extension 
    t=loader.get_template(template)
    c=Context({'logbook_entries':logbook_entries})
    response.write(t.render(c))
    return response
    

def downloadQMs(request):
    # Note to self: use get_cave method for the below
    if request.method=='GET':
        try:
            cave=Cave.objects.get(kataster_number=request.GET['cave_id'])
        except Cave.DoesNotExist:
            cave=Cave.objects.get(name=request.GET['cave_id'])

    from export import toqms

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=qm.csv'
    toqms.writeQmTable(response,cave)
    return response
    
def ajax_test(request):
    post_text = request.POST['post_data']
    return HttpResponse("{'response_text': '"+post_text+" recieved.'}", 
                                   content_type="application/json")
                                   
def eyecandy(request):
    return 

def ajax_QM_number(request):
    if request.method=='POST':
        cave=Cave.objects.get(id=request.POST['cave'])
        print(cave)
        exp=Expedition.objects.get(pk=request.POST['year'])
        print(exp)
        res=cave.new_QM_number(exp.year)

    return HttpResponse(res)

def logbook_entry_suggestions(request):
    """
    Generates a html box with suggestions about what to do with QMs
    in logbook entry text.
    """
    unwiki_QM_pattern=r"(?P<whole>(?P<explorer_code>[ABC]?)(?P<cave>\d*)-?(?P<year>\d\d\d?\d?)-(?P<number>\d\d)(?P<grade>[ABCDXV]?))"
    unwiki_QM_pattern=re.compile(unwiki_QM_pattern)
    #wikilink_QM_pattern=settings.QM_PATTERN
    
    slug=request.POST['slug']
    date=request.POST['date']
    lbo=LogbookEntry.objects.get(slug=slug, date=date)
    
    #unwiki_QMs=re.findall(unwiki_QM_pattern,lbo.text)
    unwiki_QMs=[m.groupdict() for m in unwiki_QM_pattern.finditer(lbo.text)]
    
    print(unwiki_QMs)
    for qm in unwiki_QMs:
        #try:
            if len(qm['year'])==2:
                if int(qm['year'])<50:
                    qm['year']='20'+qm['year']
                else:
                    qm['year']='19'+qm['year']

            if lbo.date.year!=int(qm['year']):
                try:
                    lbo=LogbookEntry.objects.get(date__year=qm['year'],title__icontains="placeholder for QMs in")
                except:
                    print(("failed to get placeholder for year "+str(qm['year'])))
            
            temp_QM=QM(found_by=lbo,number=qm['number'],grade=qm['grade'])
            temp_QM.grade=qm['grade']
            qm['wikilink']=temp_QM.wiki_link()
        #except:
            #print 'failed'

    print(unwiki_QMs)
    
    
    #wikilink_QMs=re.findall(wikilink_QM_pattern,lbo.text)
    attached_QMs=lbo.QMs_found.all()
    unmentioned_attached_QMs=''#not implemented, fill this in by subtracting wiklink_QMs from attached_QMs
    
    #Find unattached_QMs. We only look at the QMs with a proper wiki link.
    #for qm in wikilink_QMs:
        #Try to look up the QM. 
        
    print('got 208')
    any_suggestions=True
    print('got 210')
    return render(request,'suggestions.html',
        {
        'unwiki_QMs':unwiki_QMs,
        'any_suggestions':any_suggestions
        })

@login_required_if_public
def newFile(request, pslug = None):
#    if pslug:
#        previousfile = LogbookEntry.objects.get(slug = pslug, date = previousdate, expedition = expedition)
#        assert previousfile.filename
    if request.method == 'POST': # If the form has been submitted...
        tripForm = TripForm(request.POST) # A form bound to the POST data
#        personTripFormSet = PersonTripFormSet(request.POST)
#        if tripForm.is_valid() and personTripFormSet.is_valid(): # All validation rules pass
#            dateStr = tripForm.cleaned_data["date"].strftime("%Y-%m-%d")
#            directory = os.path.join(settings.EXPOWEB, 
#                                    "years", 
#                                    expedition.year, 
#                                    "autologbook")
#            filename = os.path.join(directory, 
#                                    dateStr + "." + slugify(tripForm.cleaned_data["title"])[:50] + ".html")
#            if not os.path.isdir(directory):
#                os.mkdir(directory)
#            if pslug and pdate:
#                delLogbookEntry(previouslbe)
#            f = open(filename, "w")
#            template = loader.get_template('dataformat/logbookentry.html')
#            context = Context({'trip': tripForm.cleaned_data, 
#                               'persons': personTripFormSet.cleaned_data,
#                               'date': dateStr,
#                               'expeditionyear': expeditionyear})
#            f.write(template.render(context))
#            f.close()
#            print logbookparsers.parseAutoLogBookEntry(filename)
#            return HttpResponseRedirect(reverse('expedition', args=[expedition.year])) # Redirect after POST
    else:
        if pslug:
             pass
#            if previouslbe.cave:
#                tripForm = TripForm(initial={"date": previousdate,
#                                             "title": previouslbe.title,
#                                             "cave": previouslbe.cave.reference(),
#                                             "location": None,
#                                             "caveOrLocation": "cave",
#                                             "html": previouslbe.text})
#            else:
#                tripForm = TripForm(initial={"date": previousdate,
#                                             "title": previouslbe.title,
#                                             "cave": None,
#                                             "location": previouslbe.place,
#                                             "caveOrLocation": "location",
#                                             "html": previouslbe.text})
#            personTripFormSet = PersonTripFormSet(initial=[{"name": get_name(py.personexpedition), 
#                                                            "TU": py.time_underground, 
#                                                            "author": py.is_logbook_entry_author}
#                                                           for py in previouslbe.persontrip_set.all()])
#        else:        
#            fileform = UploadFileForm() # An unbound form

    return render(request, 'editfile.html', {
        'fileForm': fileform,

    })

@login_required_if_public
def deleteFile(request, expeditionyear, date = None, slug = None):
    expedition = Expedition.objects.get(year=expeditionyear)
    previousdate = datetime.date(*[int(x) for x in date.split("-")])
    previouslbe = LogbookEntry.objects.get(slug = slug, date = previousdate, expedition = expedition)
    delLogbookEntry(previouslbe)
    return HttpResponseRedirect(reverse('expedition', args=[expedition.year])) # Redirect after POST

def delFile(f):
    for pt in lbe.persontrip_set.all():
        pt.delete()
    lbe.delete()
    os.remove(lbe.filename)