from django.http import HttpResponseRedirect,Http404,HttpResponse
from django.shortcuts import render_to_response,get_object_or_404,redirect,get_list_or_404
from django.template import RequestContext
from django.views.generic.create_update import create_object,update_object
from django.core.mail import mail_admins,mail_managers,BadHeaderError
from django.core.urlresolvers import reverse
from django.utils import simplejson
from django.views.decorators.cache import never_cache
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.csrf import csrf_protect
from django.template.defaultfilters import slugify
from django.conf import settings
from django.views.generic.list_detail import object_list,object_detail
from annoying.decorators import ajax_request
from input_function import *
import datetime,os,urllib,re
from models import *
from form import *

dmu_regex=re.compile( r'^p\s[0-9]{6}[a-zA-Z]{2}[a-zA-Z0-9]{2}')

@login_required
def index(request): #Fonction de la page d'index
    #return render_to_response("input/index.html")
    return HttpResponseRedirect(reverse("search-page"))#DD redirection

@login_required
@csrf_protect
def search(request):     #Fonction pour la gestion du input de recherche
    if request.POST:
        formulaire = PatientSearchForm(request.POST)
        if formulaire.is_valid():
            dmu = request.POST['dmu_number']
            data =  p(dmu)
            return add_patient(request,data)
    else:     formulaire= PatientSearchForm()
    return render_to_response("input/index.html", {'form':formulaire},context_instance=RequestContext(request))

@login_required
@csrf_protect
def add_patient(request,dico):
    return render_to_response(dico.get("template"), {'forms':dico.get("forms"),"dmu":dico.get("dmu"),"search_form":dico.get("search_form")},context_instance=RequestContext(request))

@login_required
@csrf_protect
def patient(request, pat_id, **kwargs):
    pat =get_object_or_404(Patient,dmu_number=pat_id)
    form = completePatientForm(pat)
    events, newevents = eventOrder(pat)
    return render_to_response("input/patient.html", {'forms': form, 'dmu': pat_id, 'formdialog': kwargs.get('formdialog'),
                                                     'dialogtitle': kwargs.get('dialogtitle'), 'events': events,
                                                     'newevents': newevents, 'size': kwargs.get('size'),
                                                     'event_id': kwargs.get('event_id', ''),
                                                     'error_message':kwargs.get('error_message')},context_instance=RequestContext(request))

@login_required
@csrf_protect
def edit(request):
    pat =get_object_or_404(Patient,dmu_number=request.POST['dmu_number'])
    forms = completePatientForm(req=request.POST, pat=pat)

    valid = True
    for form in forms: #forms est cree ici forms = completePatientForm(req=request.POST, pat=pat) (un peu plus haut)
        if not form.is_valid():
            valid = False
    if valid:
        forms[0].save()
        for i in range (1, len(forms)):
            model = forms[i].save(commit=False)
            model.add(pat)
            model.save()
        return HttpResponseRedirect(reverse('get-patient-data', args=(request.POST['dmu_number'],)))
    else:
        forms = completePatientForm(req=request.POST)
        return render_to_response("input/patient.html", {'forms': forms, 'dmu': request.POST['dmu_number']},context_instance=RequestContext(request))


@login_required
@csrf_protect
def create(request):
    form = completePatientForm(req = request.POST)
    valid = True
    for element in form:
        if not element.is_valid():
            valid = False
    if valid:
        pat = form[0].save()
        for i in range (1, len(form)):
            model = form[i].save(commit=False)
            model.add(pat)
            model.save()
        return HttpResponseRedirect(reverse('get-patient-data', args=(request.POST['dmu_number'],)))
    return patient(request, request.POST['dmu_number'])

@login_required
def editDialog(request, event_id):
    print("editDialog")
    """
        get event information in a form and return the corresponding page

        Argument:
        event_id : int with the id of the event
    """

    try:    event= Event.objects.select_related().get(id = event_id)
    except: raise Http404
    pat_id = event.patient_id
    model = event.content_type.model_class()
    formdialog, dialogtitle = dialogForm(event_name=model.__name__, instance=event)

    return patient(request, pat_id, event_id=event_id, formdialog = formdialog, dialogtitle = dialogtitle,
                   size = len(formdialog)>1)

@login_required
def req(request, pat_id):
    print("req")
    """
        check the instruction when a patient is selected and return the corresponding page
    """

    req = request.POST['instruction']
    #req vaut p 123456MD13 avec notre dmu de test

    if (req[:2]=='p '):
        return p(req)

    elif (req[:2]=='e '):
        try:
            formdialog, dialogtitle = exam(req)
        except:
            return patient(request, pat_id, error_message= "L'examen n'existe pas")

    elif (req=='s'):
        formdialog = [SymptomsForm()]
        dialogtitle = "Symptoms"

    elif (req[:2]=='t '):
        try:
            formdialog, dialogtitle = treat(req)
        except:
            return patient(request, pat_id, error_message= "Le traitement n'existe pas")

    elif (req=='tumor'):
        formdialog = completeTumorForm()
        dialogtitle = "Tumor"

    else:
        return patient(request, pat_id, error_message= "La requete n'existe pas")

    return patient(request, pat_id, formdialog = formdialog, dialogtitle = dialogtitle, size = len(formdialog)>1)

@login_required
def patientEventSave(request, pat_id, event_name, event_id=None):
    print("patientEventSave")
    """
        save the event of a patient from the event form

        Arguments:
        pat_id : string with the dmu number of the patient
        event: string with the name of the event
    """
    pat =Patient.objects.get(dmu_number = pat_id)
    event=None
    if (event_id):
        event = Event.objects.get(id = event_id)

    formdialog, dialogtitle = dialogForm(event_name=event_name, post=request.POST, instance=event)

    if formdialog[0].is_valid():
        dialog=formdialog[0].save(commit=False)
        dialog.patient=pat
        dialog.before=None
        dialog.after=None
        dialog.save()
        for i in range (1, len(formdialog)):
            model = formdialog[i].save(commit=False)
            model.add(dialog)
            model.save()

        return  patient(request, pat_id)

@login_required
def beforeAfterSave(request, event_id,before_id,after_id):
    print("beforeAfterSave")
    """
        save values of before and after fields when the user puts the event element between two events

        Arguments:
        event_id : int with the id of the event
        before_id: int with the id of the event before
        after_id: int with the id of the event after
    """
    event= Event.objects.get(id = event_id)
    event_bef = Event.objects.get(id=before_id)
    event_aft = Event.objects.get(id=after_id)

    if (event_bef.date):
        event.before= event_bef.date
    else:
        event.before= event_bef.after
    if (event_aft.date):
        event.after= event_aft.date
    else:
        event.after= event_aft.before
    event.save()
    dmu = event.patient.dmu_number

    return HttpResponseRedirect(reverse('get-patient-data', args=(dmu,)))