from django.http.response import HttpResponse
from src.core.pyros_django import scientific_program
from django.shortcuts import render, redirect, get_object_or_404, reverse
from django.contrib.auth import authenticate, login

from django.contrib.auth.decorators import login_required

from .forms import PeriodForm, ScientificProgramForm, InstituteForm, SP_PeriodForm

from src.core.pyros_django.dashboard.decorator import level_required

from common.models import ScientificProgram, Institute, Period, SP_Period_User, SP_Period, PyrosUser, UserLevel, SP_Period_Guest

from django.http import HttpResponseRedirect

from datetime import date, datetime
from django.conf import settings
from django.core.mail import send_mail
from django.db.models import Max
from dateutil.relativedelta import relativedelta
from django.utils import timezone
from django.db.models import Q,F
from .functions import get_global_svg_timeline, get_svg_timeline, get_proposal_svg_timeline
from django.views.decorators.csrf import csrf_exempt
import re

# Scientific program CRUD

@login_required
@level_required("Admin", "Observer","TAC","Unit-PI","Unit-board")
def index_scientific_program(request):
    today = timezone.now().date()
    does_next_period_exist = Period.objects.filter(
        start_date__gt=today).order_by("start_date").first() != None
    future_period = Period.objects.filter(
        start_date__gt=today, submission_start_date__lte=today).order_by("start_date").first()
    previous_period = Period.objects.filter(
        end_date__lt=today, property_of_data_end_date__lt=today).first()
    current_period = Period.objects.currently_active_period()
    evaluation_periods = Period.objects.filter(
        start_date__gte=today, submission_end_date__lte=today,unit_pi_validation_start_date__gt=today)
    #validation_periods = Period.objects.filter(
    #    start_date__gte=today, submission_end_date__gt=today,unit_pi_validation_start_date__gte=today,start_date__lt=F("start_date") + relativedelta(days=-5)) 
    validation_periods = Period.objects.filter(
        start_date__gte=today, submission_end_date__gt=today,unit_pi_validation_start_date__gte=today)
    sp_to_be_evaluated = SP_Period.objects.filter(period__in=evaluation_periods,status__in=(SP_Period.STATUSES_SUBMITTED,SP_Period.STATUSES_EVALUATED)).count() > 0
    sp_to_be_validated = SP_Period.objects.filter(period__in=validation_periods,status__in=(SP_Period.STATUSES_EVALUATED,SP_Period.STATUSES_ACCEPTED,SP_Period.STATUSES_REJECTED)).count() > 0
    # date_diff_today_end_of_property will give a value to make
    # the date of today shift through the time line
    if previous_period:
        temp = today - previous_period.start_date 
        date_diff_today_end_of_property = temp.days / 12.5 
    else:
        temp = today - current_period.start_date 
        date_diff_today_end_of_property = temp.days / 12.5 + 15
    CAN_VALIDATE_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board") and sp_to_be_validated
    CAN_EVALUATE_SP = request.session.get("role") in ("Admin","TAC") and sp_to_be_evaluated
    CAN_SUBMIT_SP =  request.session.get("role") in ("Admin","Observer") and does_next_period_exist
    CAN_VIEW_SP =  request.session.get("role") in ("Admin","Observer")
    CAN_VIEW_ALL_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    CAN_VIEW_EXPLOITATION_PERIOD = request.session.get("role") in ("Admin","Observer","Unit-PI","Unit-board")
    CAN_CREATE_EXPLOITATION_PERIOD = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    svg = get_svg_timeline(previous_period,current_period,future_period)
    global_svg = get_global_svg_timeline(previous_period,current_period,future_period)
    #global_svg = get_global_svg_timeline(current_period,current_period,future_period)
    return render(request, "scientific_program/index.html", {
        "base_template": "base.html",
        "previous_period": previous_period,
        "current_period": current_period,
        "future_period": future_period,
        "today": today,
        "date_diff_today_end_of_property": date_diff_today_end_of_property,
        "svg":svg,
        "global_svg":global_svg,
        "CAN_VALIDATE_SP": CAN_VALIDATE_SP,
        "CAN_EVALUATE": CAN_EVALUATE_SP,
        "CAN_SUBMIT_SP":CAN_SUBMIT_SP,
        "CAN_VIEW_SP": CAN_VIEW_SP,
        "CAN_VIEW_EXPLOITATION_PERIOD": CAN_VIEW_EXPLOITATION_PERIOD,
        "CAN_CREATE_EXPLOITATION_PERIOD": CAN_CREATE_EXPLOITATION_PERIOD,
        "CAN_VIEW_ALL_SP": CAN_VIEW_ALL_SP
    })

@login_required

@level_required("Admin", "Observer")
def create_scientific_program(request):
    SP_form = ScientificProgramForm()

    if request.POST:

        SP_form = ScientificProgramForm(request.POST)
        if SP_form.is_valid():
            institute = request.user.institute
            temp_SP = SP_form.save(commit=False)
            temp_SP.institute = Institute.objects.get(name=institute)
            temp_SP.status = SP_Period.STATUSES_DRAFT
            temp_SP.sp_pi = request.user
            temp_SP.save()
            return HttpResponseRedirect(reverse("create_scientific_program_period",args=[temp_SP.id]))
    return render(request, "scientific_program/create_scientific_program.html", {
        "SPForm": SP_form,
    })

@level_required("Admin", "Observer")
@login_required
def create_scientific_program_period(request,id_SP,id_SP_Period=None):
    SP = ScientificProgram.objects.get(id=id_SP)
    today = timezone.now().date()
    next_periods = Period.objects.filter(submission_start_date__lte=today,submission_end_date__gt=today, start_date__gt=today)

    is_sp_reproposed = False

    if SP.sp_pi != request.user:
        HttpResponseRedirect(reverse("index_scientific_program"))
    SP_Period_form = SP_PeriodForm()
    if id_SP_Period != None:
        sp_period_template = SP_Period.objects.get(id=id_SP_Period)
        initial_data = {
            "quota_minimal":sp_period_template.quota_minimal,
            "quota_nominal":sp_period_template.quota_nominal,
            "over_quota_duration":sp_period_template.over_quota_duration,
            "token":sp_period_template.token
        }
        period_id_to_be_excluded = SP_Period.objects.filter(scientific_program=sp_period_template.scientific_program).values_list("period",flat=True)
        next_periods = Period.objects.filter(submission_start_date__lte=today,submission_end_date__gt=today, start_date__gt=today).exclude(id__in=period_id_to_be_excluded)
        SP_Period_form = SP_PeriodForm(initial=initial_data)

        is_sp_reproposed = True

    #next_period = Period.objects.filter(
    #    start_date__gt=today).order_by("start_date").first()
    error = False
    error_message = ""
    list_of_emails = None

    recipient_list = []

    if request.POST:
        SP_Period_form = SP_PeriodForm(request.POST)
        if SP_Period_form.is_valid():

            """ if request.POST.getlist("user"):

                for user in request.POST.getlist("user"):
                    user_instance = PyrosUser.objects.get(id=int(user))
                    SP_Period_User.objects.create(SP_Period=sp_period,user=user_instance,is_SP_PI=False)

            """

            if not is_sp_reproposed and request.POST.get("users"):

                regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
                list_of_emails = request.POST.get("users").strip()

                for email in list_of_emails.split(","):
                    if re.fullmatch(regex, email):
                        recipient_list.append(email)
                    else:
                        error = True
                        error_message = f"Invalid mail for {email}"

            if not error:
                institute = request.user.institute
                selected_period = Period.objects.get(id=request.POST.get("period"))

                current_sp = ScientificProgram.objects.get(id=id_SP)
                sp_period = SP_Period_form.save(commit=False)
                sp_period.period = selected_period
                #sp_period.period = next_period
                sp_period.scientific_program = current_sp
                sp_period.save()

                sp_pi_user = PyrosUser.objects.get(id=request.user.id)
                #SP_Period_User.objects.create(
                #    SP_Period=sp_period, user=sp_pi_user, is_SP_PI=True)
                domain = settings.DEFAULT_DOMAIN
                url = f"{domain}{reverse('sp_register',args=(current_sp.pk,sp_period.period.pk))}"
                mail_subject = '[PyROS CC] New registration to an observing proposal'
                mail_message = (f"Hi,\n\nYou were invited to join an observing proposal that as been submitted using PyROS.\n"
                                f"The name of the proposal is {current_sp.name} and his PI is {sp_pi_user.first_name} {sp_pi_user.last_name}.\n"
                                f"To accept this invitation, click on the following link : {url}\n"
                                "You might be asked to login first and will be redirected to the proposal page.\n"
                                "If the redirection doesn't work, click again on the link after you've logged in.\n"
                                "If you don't own an PyROS account, go on the website in order to create an account with the same mail adress that you are using to read this mail."
                                "\n\nCordially,\n\nPyROS Control Center")
                if len(recipient_list) > 0:

                    for recipient in recipient_list:
                        guest = SP_Period_Guest.objects.create(
                            SP_Period=sp_period, email=recipient)
                        send_mail(
                            mail_subject,
                            mail_message,
                            from_email=None,
                            recipient_list=[recipient],
                            fail_silently=False,
                        )

                if is_sp_reproposed:
                    previous_sp_periods = SP_Period.objects.filter(scientific_program=current_sp,period__lt=selected_period)

                    users_of_previous_period_for_sp = SP_Period_User.objects.filter(SP_Period__in=previous_sp_periods).values_list("user",flat=True).distinct()

                    for user in users_of_previous_period_for_sp:
                        SP_Period_User.objects.create(SP_Period=sp_period,user=PyrosUser.objects.get(id=user))
                return HttpResponseRedirect(reverse("detail_scientific_program",args=[current_sp.id]))

                #return HttpResponseRedirect(reverse("own_scientific_program_list"))

    return render(request, "scientific_program/create_scientific_program_period.html", {
        "scientific_program":SP,
        "SP_PeriodForm": SP_Period_form,
        "error_message": error_message,
        "list_of_emails": list_of_emails,

        "next_periods": next_periods,
        "is_sp_reproposed":is_sp_reproposed

    })

@login_required

@level_required("Admin", "Observer")
def create_scientific_program_with_template(request, id_SP):
    SP_form = ScientificProgramForm(instance=ScientificProgram.objects.get(id=id_SP))
    if request.POST:
        SP_form = ScientificProgramForm(request.POST)
        if SP_form.is_valid():
            institute = request.user.institute
            temp_SP = SP_form.save(commit=False)
            temp_SP.institute = Institute.objects.get(name=institute)
            temp_SP.status = SP_Period.STATUSES_DRAFT
            temp_SP.sp_pi = request.user
            temp_SP.save()
            return HttpResponseRedirect(reverse("create_scientific_program_period",args=[temp_SP.id]))
    return render(request, "scientific_program/create_scientific_program.html", {
        "SPForm": SP_form,
    })

@login_required
@level_required("Admin", "Observer")
def list_scientific_program_period_repropose(request):
    select_message = "Submit again an existing SP but for a new exploitation period (instance)"
    none_message = f"There is no existing SP to be submitted for a new exploitation period"

    sp_where_user_is_sp_pi = ScientificProgram.objects.filter(sp_pi=request.user)

    if sp_where_user_is_sp_pi is None:
        return HttpResponseRedirect(reverse("index_scientific_program"))
    sp_period_of_user = SP_Period.objects.filter(scientific_program__in=sp_where_user_is_sp_pi)
    if not sp_period_of_user and sp_where_user_is_sp_pi is None: 
        return HttpResponseRedirect(reverse("index_scientific_program"))

    #sp_of_user = SP_Period_User.objects.filter(user=request.user.id).values_list("SP_Period",flat=True)
    #sp_period_of_user =  SP_Period.objects.filter(scientific_program__in=sp_where_user_is_sp_pi,status=SP_Period.STATUSES_ACCEPTED).values("scientific_program","id").annotate("scientific_program")
    #sp_period_active_of_user = SP_Period.objects.filter(scientific_program__in=sp_where_user_is_sp_pi,period=Period.objects.currently_active_period())
    sp_period_of_user = []

    # sp_to_be_proposed = list of Scientific Program that are NOT linked to a Period
    list_of_sp_to_be_proposed = []

    today = timezone.now().date()
    next_proposal_periods = Period.objects.filter(submission_start_date__lte=today,submission_end_date__gt=today, start_date__gt=today).values_list("id",flat=True)

    for sp in sp_where_user_is_sp_pi:

        is_sp_associated_with_period = SP_Period.objects.filter(scientific_program=sp).count() > 0
        if is_sp_associated_with_period:
            # get latest period that has been associated with that SP
            max_period_of_sp = SP_Period.objects.filter(scientific_program=sp).aggregate(Max("period"))["period__max"]

            # get all periods where this SP is associated
            periods_of_sp = SP_Period.objects.filter(scientific_program=sp).values("period")
            if max_period_of_sp :
                # remove the periods where this sp is associated
                next_proposal_periods = next_proposal_periods.exclude(id__in=periods_of_sp)
                if next_proposal_periods.count() > 0:
                    # this SP can be reproposed for a next proposal period
                    sp_period_of_user.append(SP_Period.objects.get(scientific_program=sp,period=max_period_of_sp))
        else:
            list_of_sp_to_be_proposed.append(sp)

    #sp_period_active_of_user = SP_Period.objects.filter(scientific_program__in=sp_where_user_is_sp_pi).annotate(Max("period")).distinct("scientific_program_id")

    list_of_sp = []
    are_there_only_sp = False
    # SP_Period where user is a SP_PI
    list_of_sp = sp_period_of_user

    if len(list_of_sp) ==  0 and len(list_of_sp_to_be_proposed) == 0:

        list_of_sp = ScientificProgram.objects.filter(sp_pi=request.user).exclude(id__in=SP_Period.objects.all().values("scientific_program"))
        # This boolean will tell if we're using ScientificProgram objects within the view or SP_Period objects
        are_there_only_sp = True
    return render(request, "scientific_program/list_of_scientific_program_select.html", {
        "select_message": select_message,
        "none_message": none_message,
        "list_of_sp": list_of_sp,

        "list_of_sp_to_be_proposed":list_of_sp_to_be_proposed,

        "list_of_sp_to_be_reproposed": True,
        "are_there_only_sp":are_there_only_sp
    })

@login_required
@level_required("Admin", "Observer")
def list_scientific_program_as_template(request):
    select_message = "Please select a SP from the list below as template:"
    none_message = f"There is no SP to be used as template"
    sp_of_user = SP_Period_User.objects.filter(user=request.user.id).values_list("SP_Period",flat=True)
    list_of_sp = []
    are_there_only_sp = False
    for sp_period in sp_of_user:
        list_of_sp.append(SP_Period.objects.get(id=sp_period).order_by("-id"))
    if len(list_of_sp) ==  0:
        list_of_sp = ScientificProgram.objects.filter(sp_pi=request.user).order_by("-id")
        are_there_only_sp = True
    return render(request, "scientific_program/list_of_scientific_program_select.html", {
        "select_message": select_message,
        "none_message": none_message,
        "list_of_sp": list_of_sp,
        "list_of_sp_as_template": True,
        "are_there_only_sp":are_there_only_sp
    })


@login_required
@level_required("Admin", "TAC")
def list_submitted_scientific_program(request):
    select_message = "Please select a SP from the list below for evaluation:"
    today = timezone.now().date()
    next_period = Period.objects.filter(
        start_date__gte=today, submission_end_date__lte=today,unit_pi_validation_start_date_gt=today).first()
    none_message = f"There is no SP to be evaluated for next exploitation period {next_period}"
    # Note : ~Q mean not query
    list_of_sp = SP_Period.objects.filter(Q(referee1=None) & ~Q(referee2=request.user) | ~Q(
        referee1=request.user) & Q(referee2=None), status=SP_Period.STATUSES_SUBMITTED, period=next_period)
    list_of_evaluated_sp = []
    for sp in list_of_sp:
        if sp.referee1 == request.user or sp.referee2 == request.user:
            list_of_evaluated_sp.append(sp)

    return render(request, "scientific_program/list_of_scientific_program_select.html", {
        "select_message": select_message,
        "none_message": none_message,
        "list_of_sp": list_of_sp,
        "list_of_evaluated_sp": list_of_evaluated_sp
    })


@login_required

@level_required("Admin", "Unit-PI","Unit-board")

def list_evaluated_scientific_program(request):
    select_message = "Please select a SP from the list below for validation:"
    today = timezone.now().date()
    next_period = Period.objects.filter(
        start_date__gte=today, submission_start_date__lte=today).first()
    none_message = f"There is no SP to be validated for next exploitation period {next_period}"
    list_of_sp = SP_Period.objects.filter(
        status=SP_Period.STATUSES_EVALUATED, period=next_period)
    list_of_validated_sp = []
    for sp in list_of_sp:
        if sp.quota_allocated > 0 and sp.is_valid == SP_Period.IS_VALID_ACCEPTED or sp.is_valid == SP_Period.IS_VALID_REJECTED:
            list_of_validated_sp.append(sp)

    return render(request, "scientific_program/list_of_scientific_program_select.html", {
        "select_message": select_message,
        "none_message": none_message,
        "list_of_sp": list_of_sp,
        "list_of_validated_sp": list_of_validated_sp
    })


@login_required
def accept_sp_invitation(request, id_SP, id_period):

    """
    An invitation to join an SP is valid until the end of Exploitation period

    """

    sp_period = SP_Period.objects.get(scientific_program=id_SP, period=id_period)
    current_user = PyrosUser.objects.get(username=request.user)
    is_user_guest_of_sp = SP_Period_Guest.objects.filter(
        SP_Period=sp_period, email=current_user.email).exists()
    today = timezone.now().date()
    period = Period.objects.get(id=id_period)
    if is_user_guest_of_sp and period.end_date > today:
        new_user = SP_Period_User.objects.create(
            SP_Period=sp_period, user=current_user)
        if new_user:
            SP_Period_Guest.objects.get(
                SP_Period=sp_period, email=current_user.email).delete()
            return HttpResponseRedirect(reverse("detail_scientific_program_period", kwargs={"id_sp": id_SP, "id_period": id_period}))
    return HttpResponseRedirect(reverse("index"))


@level_required("Admin", "Unit-PI", "Observer", "TAC")
@login_required
def edit_scientific_program_period(request, id_sp, id_period):
    scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
    SPForm = ScientificProgramForm(
        request.POST or None, instance=scientific_program)
    error = False
    error_message = ""
    today = timezone.now().date()
    sp_period = SP_Period.objects.get(
        scientific_program=scientific_program, period=Period.objects.get(id=id_period))

    period=Period.objects.get(id=id_period)

    SP_Period_form = SP_PeriodForm(request.POST or None, instance=sp_period)
    sp_pi = scientific_program.sp_pi

    if request.session.get("role") == "Observer" and request.user.id != sp_pi.id:

        return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
    guests = list(SP_Period_Guest.objects.filter(
        SP_Period=sp_period).values_list("email", flat=True))
    user_of_sp = SP_Period_User.objects.filter(
        SP_Period__exact=sp_period)
    users_informations = PyrosUser.objects.filter(
        id__in=user_of_sp.values_list("user", flat=True))
    guests = ",".join(guests)

    error = False
    error_message = ""
    list_of_emails = None
    recipient_list = []

    if request.POST:

        if SP_Period_form.is_valid():
            # can send invitation until the end of exploitation
            if request.POST.get("users") and today < period.end_date:
                # Invite user to join the SP
                regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
                list_of_emails = request.POST.get("users").strip()
                
                for email in list_of_emails.split(","):
                    if re.fullmatch(regex, email):
                        recipient_list.append(email)
                    else:
                        error = True
                        error_message = f"Invalid mail for {email}"
                if not error:
                    domain = settings.DEFAULT_DOMAIN
                    url = f"{domain}{reverse('sp_register',args=(scientific_program.pk,sp_period.period.pk))}"
                    mail_subject = '[PyROS CC] New registration to an observing proposal'
                    mail_message = (f"Hi,\n\nYou were invited to join an observing proposal that as been submitted using PyROS.\n"
                                    f"The name of the proposal is {scientific_program.name} and his PI is {sp_pi.first_name} {sp_pi.last_name}.\n"
                                    f"To accept this invitation, click on the following link : {url}\n"
                                    "You might be asked to login first and will be redirected to the proposal page.\n"
                                    "If the redirection doesn't work, click again on the link after you've logged in.\n"
                                    "If you don't own an PyROS account, go on the website in order to create an account with the same mail adress that you are using to read this mail."
                                    "\n\nCordially,\n\nPyROS Control Center")
                    if len(recipient_list) > 0:
                        try:
                            # Delete previous guests (resetting list of guests)
                            SP_Period_Guest.objects.filter(SP_Period=sp_period).delete()
                        finally:
                            for recipient in recipient_list:
                                guest = SP_Period_Guest.objects.create(
                                    SP_Period=sp_period, email=recipient)
                                send_mail(
                                    mail_subject,
                                    mail_message,
                                    from_email=None,
                                    recipient_list=[recipient],
                                    fail_silently=False,
                                )
                else:
                    return render(request, 'scientific_program/scientific_program_detail_edit.html', {
                            'id_sp': id_sp,
                            "id_period": id_period,
                            "SPForm": SPForm,
                            "period": sp_period.period,
                            "guests": guests,
                            "users_of_sp_period": users_informations,
                            "SP_PeriodForm": SP_Period_form,
                            "sp_period": sp_period,
                            "error_message":error_message
                        })
                SP_period = SP_Period_form.save()
                # save changes on user list 
                if request.POST.getlist("user"):
                    for sp_period_user in users_informations:
                        if sp_period_user.id not in map(int, request.POST.getlist("user")):
                            sp_period_user.delete()

                    for user in request.POST.getlist("user"):
                        user_instance = PyrosUser.objects.get(id=int(user))
                        if user_instance not in users_informations:
                            SP_Period_User.objects.create(
                                SP_Period=sp_period, user=user_instance)
                else:
                    SP_Period_User.objects.filter(
                        SP_Period=sp_period).delete()
                return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)

        if SP_Period_form.is_valid() and request.session.get("role") == "TAC" and sp_period.status != SP_Period.STATUSES_DRAFT:
            # vote TAC
            if sp_period.referee1 == None or sp_period.referee1 == request.user and request.POST.get("vote_referee1") and request.POST.get("reason_referee1"):
                tac = request.user.id
                SP_Period_form.save(commit=False)
                SP_Period_form.vote_referee1 = request.POST.get(
                    "vote_referee1")
                SP_Period_form.reason_referee1 = request.POST.get(
                    "reason_referee1")
                SP_Period_form.save()
                sp_period.referee1 = PyrosUser.objects.get(id=tac)
                #if sp_period.referee2 != None:
                    #sp_period.status = SP_Period.STATUSES_EVALUATED
                sp_period.save()
            if sp_period.referee1 != None and sp_period.referee2 == None or sp_period.referee2 == request.user and request.POST.get("vote_referee2") and len(request.POST.get("reason_referee2")) > 0:
                tac = request.user.id
                SP_Period_form.save(commit=False)
                SP_Period_form.vote_referee2 = request.POST.get(
                    "vote_referee2")
                SP_Period_form.reason_referee2 = request.POST.get(
                    "reason_referee2")
                SP_Period_form.save()
                sp_period.referee2 = PyrosUser.objects.get(id=tac)
                #if sp_period.referee1 != None:
                    #sp_period.status = SP_Period.STATUSES_EVALUATED
                sp_period.save()
            return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
        elif SP_Period_form.is_valid() and request.session.get("role") in ["Unit-PI", "Unit-board"] and sp_period.status in [SP_Period.STATUSES_EVALUATED, SP_Period.STATUSES_ACCEPTED, SP_Period.STATUSES_REJECTED]:
            #if request.POST.get("is_valid") != None:
                #sp_period.status = request.POST.get("is_valid")
            SP_Period_form.save()
            sp_period.save()
            return redirect('detail_scientific_program_period', id_sp=scientific_program.id, id_period=id_period)
        else:
            print(SP_Period_form.errors)
    return render(request, 'scientific_program/scientific_program_detail_edit.html', {
        'id_sp': id_sp,
        "id_period": id_period,
        "SPForm": SPForm,
        "period": sp_period.period,
        "guests": guests,
        "users_of_sp_period": users_informations,
        "SP_PeriodForm": SP_Period_form,

        "sp_period": sp_period,
        "error_message":error_message

    })

@level_required("Admin", "Unit-PI", "Observer", "TAC")

@login_required

def detail_scientific_program(request, id):

    scientific_program = get_object_or_404(ScientificProgram, pk=id)

    sp_periods = SP_Period.objects.filter(
        scientific_program=scientific_program).order_by("-id")
    sp_pi = scientific_program.sp_pi

    if request.session.get("role") == "Observer" and sp_pi != request.user and not SP_Period_User.objects.filter(SP_Period__in=sp_periods, user=PyrosUser.objects.get(id=request.user.id)).exists() :
        return HttpResponseRedirect(reverse("index_scientific_program"))

    today = timezone.now().date()
    next_proposal_period =  Period.objects.filter(
        start_date__gt=today, submission_start_date__lte=today).order_by("start_date").first()

    if next_proposal_period:
        is_future_period_in_proposal = next_proposal_period.id not in sp_periods.values_list("period",flat=True)
    else:
        is_future_period_in_proposal = False

    CAN_REPROPOSE_SP = sp_pi == request.user and request.session.get("role") == "Observer" and is_future_period_in_proposal

    CAN_DELETE_SP = not sp_periods and (sp_pi == request.user and request.session.get("role") == "Observer") or (request.session.get("role") in ("Admin","Unit-PI","Unit-board"))

    return render(request, 'scientific_program/scientific_program_detail.html', {
        'scientific_program': scientific_program,
        "sp_pi": sp_pi,
        "sp_periods": sp_periods,

        "CAN_REPROPOSE_SP": CAN_REPROPOSE_SP,
        "CAN_DELETE_SP": CAN_DELETE_SP

    })


@level_required("Admin", "Unit-PI", "Observer", "TAC")
@login_required
def detail_scientific_program_period(request, id_sp, id_period):
    scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
    sp_period = SP_Period.objects.get(
        scientific_program=scientific_program, period=Period.objects.get(id=id_period))
    user_of_sp = SP_Period_User.objects.filter(
        SP_Period=sp_period)
    users_informations = PyrosUser.objects.filter(
        id__in=user_of_sp.values_list("user", flat=True))
    sp_pi = scientific_program.sp_pi
    guests = list(SP_Period_Guest.objects.filter(
        SP_Period=sp_period).values_list("email", flat=True))

    # User is observer and not from this SP

    if request.session.get("role") == "Observer":
        if sp_pi!=request.user and not SP_Period_User.objects.filter(SP_Period=sp_period, user=PyrosUser.objects.get(id=request.user.id)).exists():
            return HttpResponseRedirect(reverse("index_scientific_program"))
    CAN_OBSERVER_EDIT = request.session.get("role") in ("Admin","Observer") and sp_pi == request.user and sp_period.status == SP_Period.STATUSES_DRAFT
    CAN_TAC_EVALUATE = request.session.get("role") in ("Admin","TAC") and sp_period.status == SP_Period.STATUSES_SUBMITTED
    CAN_UNIT_PI_VALIDATE = request.session.get("role") in ("Unit-PI","Unit-board") and sp_period.status == SP_Period.STATUSES_EVALUATED
    CAN_OBSERVER_DELETE = request.session.get("role") in ("Admin","Observer") and sp_period.status == SP_Period.STATUSES_DRAFT

    CAN_VIEW_TAC_VOTES = request.session.get("role") in ("Admin","Unit-PI","Unit-board")

    CAN_SUBMIT_PROPOSAL = request.user == sp_pi and request.session.get("role") == "Observer" and sp_period.status == SP_Period.STATUSES_DRAFT

    return render(request, 'scientific_program/scientific_program_period_detail.html', {
        'scientific_program': scientific_program,
        "users": users_informations,
        "sp_pi": sp_pi,
        "period": sp_period.period,
        "guests": guests,
        "sp_period": sp_period,
        "CAN_OBSERVER_EDIT": CAN_OBSERVER_EDIT,
        "CAN_TAC_EVALUATE": CAN_TAC_EVALUATE,
        "CAN_UNIT_PI_VALIDATE": CAN_UNIT_PI_VALIDATE,
        "CAN_OBSERVER_DELETE": CAN_OBSERVER_DELETE,
        "is_proposal": True,

        "CAN_VIEW_TAC_VOTES": CAN_VIEW_TAC_VOTES,
        "CAN_SUBMIT_PROPOSAL": CAN_SUBMIT_PROPOSAL

    })

@level_required("Admin", "Unit-PI", "Observer")

@login_required()

def submit_proposal(request, id):
    sp_period = SP_Period.objects.get(id=id)
    if sp_period.status == SP_Period.STATUSES_DRAFT:
        sp_period.status = SP_Period.STATUSES_SUBMITTED
        sp_period.save()
    return HttpResponseRedirect(reverse("detail_scientific_program_period", args=[sp_period.scientific_program.id, sp_period.period.id]))


@level_required("Admin", "Unit-PI", "Observer")
@login_required()

def delete_scientific_program(request, id_sp):
    scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
    sp_periods = SP_Period.objects.filter(scientific_program=scientific_program)
    if sp_periods:
        for sp_period in sp_periods:
            SP_Period_User.objects.filter(SP_Period=sp_period).delete()
            SP_Period_Guest.objects.filter(SP_Period=sp_period).delete()
        sp_periods.delete()

    scientific_program.delete()

    return HttpResponseRedirect(reverse('index_scientific_program'))

@level_required("Admin", "Unit-PI", "Observer")
@login_required()
def delete_scientific_program_period(request, id_sp, id_period):
    scientific_program = get_object_or_404(ScientificProgram, pk=id_sp)
    sp_period = SP_Period.objects.get(
        scientific_program=scientific_program, period=Period.objects.get(id=id_period))
    if sp_period.status == SP_Period.STATUSES_DRAFT:
        sp_period_users = SP_Period_User.objects.filter(SP_Period=sp_period)
        sp_period_guests = SP_Period_Guest.objects.filter(SP_Period=sp_period)
        sp_period_guests.delete()
        sp_period_users.delete()
        sp_period.delete()
    return HttpResponseRedirect(reverse('detail_scientific_program',args=[scientific_program.id]))

@login_required

@level_required("Admin", "Unit-PI", "Observer", "Unit-board")

def scientific_program_list(request):
    sp_of_user = []
    # get sp_period where the period is an active period and are accepted
    scientific_programs = ScientificProgram.objects.all().order_by("-id")

    CAN_VIEW_ALL_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    CAN_VIEW_HIS_SP = request.session.get("role") == "Observer"

    if not CAN_VIEW_ALL_SP:
        # get all SP associated to that user
        sp_periods_of_user = SP_Period_User.objects.filter(user=request.user.id).values_list("SP_Period",flat=True)
        list_of_sp_id = SP_Period.objects.filter(id__in=sp_periods_of_user).values("scientific_program")
        sp_of_user = ScientificProgram.objects.filter(id__in=list_of_sp_id)

    return render(request, 'scientific_program/scientific_programs.html', {
        'scientific_programs': scientific_programs,

        "sp_of_user": sp_of_user,
        "CAN_VIEW_ALL_SP": CAN_VIEW_ALL_SP,
        "CAN_VIEW_HIS_SP": CAN_VIEW_HIS_SP

    })


@login_required
@level_required("Observer")
def own_scientific_program_list(request):
    sp_of_user = []
    # get sp_period where the period is an active period and are accepted
    scientific_programs = ScientificProgram.objects.all().order_by("-id")

    CAN_VIEW_ALL_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    CAN_VIEW_HIS_SP = request.session.get("role") == "Observer"

    if (len(scientific_programs) > 0):

        # get all SP where user is sp_pi

        sp_of_user = ScientificProgram.objects.filter(sp_pi=request.user).order_by("-id")
    else:

        scientific_programs = None

    return render(request, 'scientific_program/scientific_programs.html', {
        'scientific_programs': scientific_programs,

        "sp_of_user": sp_of_user,
        "CAN_VIEW_ALL_SP": CAN_VIEW_ALL_SP,
        "CAN_VIEW_HIS_SP": CAN_VIEW_HIS_SP

    })



#Get Proposal timeline of period 

@level_required("Admin", "Unit-PI", "Observer", "TAC")
@login_required
@csrf_exempt
def get_proposal_timeline(request):
    if request.POST.get("period_id"):
        return HttpResponse(get_proposal_svg_timeline(Period.objects.get(id=request.POST["period_id"])))

# Institute CRUD

@login_required

@level_required("Admin", "Unit-PI","Unit-board")

def create_institute(request):
    form = InstituteForm(request.POST)
    if request.POST:
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse("institute_list"))
    form = InstituteForm()

    return render(request, "scientific_program/create_institute.html", {"form": form})

@level_required("Admin", "Unit-PI","Unit-board")

@login_required

def edit_institute(request, id):

    edit = get_object_or_404(Institute, pk=id)
    form = InstituteForm(request.POST or None, instance=edit)
    if form.is_valid():
        form.save()
        return redirect('detail_institute', id=id)

    return render(request, 'scientific_program/institute_detail_edit.html', {'id': id, 'form': form})

@level_required("Admin", "Unit-PI", "Observer", "Operator", "TAC", "Management board member")

@login_required

def detail_institute(request, id):

    institute = get_object_or_404(Institute, pk=id)

    representative_member = PyrosUser.objects.get(
        is_institute_representative=True, institute=institute)

    scientific_programs = ScientificProgram.objects.filter(institute=institute)

    CAN_EDIT_INSTITUTE = request.session.get("role") in ("Admin", "Unit-PI","Unit-board")
    CAN_DELETE_INSTITUTE = request.session.get("role") in ("Admin", "Unit-PI","Unit-board")

    return render(request, 'scientific_program/institute_detail.html', {
        'institute': institute,
        "representative_member": representative_member,

        "scientific_programs": scientific_programs,
        "CAN_EDIT_INSTITUTE": CAN_EDIT_INSTITUTE,
        "CAN_DELETE_INSTITUTE": CAN_DELETE_INSTITUTE

    })

@level_required("Admin", "Unit-PI","Unit-board")

@login_required()

def delete_institute(request, id):

    institute = get_object_or_404(Institute, pk=int(id))
    institute.delete()
    return HttpResponseRedirect(reverse('institute_list'))


@login_required

@level_required("Admin", "Unit-PI", "Observer", "Operator", "TAC", "Management board member")

def institute_list(request):
    institutes = Institute.objects.all()

    CAN_ADD_INSTITUTE = request.session.get("role") in ("Admin", "Unit-PI", "Unit-board")
    return render(request, 'scientific_program/institutes.html', {
        'institutes': institutes,
        "CAN_ADD_INSTITUTE": CAN_ADD_INSTITUTE
    })

# Exploitation Periods CRUD

@login_required

@level_required("Admin", "Unit-PI", "Unit board")

def create_period(request):

    today = timezone.now().date()
    possible_start_date = Period.objects.aggregate(Max("end_date"))
    possible_end_date = possible_start_date["end_date__max"] + \
        relativedelta(months=+6)

    possible_start_date_as_datetime = possible_start_date["end_date__max"]
    possible_end_date_as_datetime = possible_start_date["end_date__max"] + relativedelta(
        months=+6)

    possible_start_date = datetime.strftime(
        possible_start_date["end_date__max"], "%d/%m/%Y")
    possible_end_date = datetime.strftime(possible_end_date, "%d/%m/%Y")

    possible_submission_start_date = possible_start_date_as_datetime + \
        relativedelta(months=-6)
    possible_submission_start_date = datetime.strftime(
        possible_submission_start_date, "%d/%m/%Y")

    possible_submission_end_date = possible_start_date_as_datetime + \
        relativedelta(months=-1) + relativedelta(days=-15)
    possible_submission_end_date = datetime.strftime(
        possible_submission_end_date, "%d/%m/%Y")

    possible_validation_start_date = possible_start_date_as_datetime + \
        relativedelta(days=-15)
    possible_validation_start_date = datetime.strftime(
        possible_validation_start_date, "%d/%m/%Y")

    possible_property_end_date = possible_end_date_as_datetime + \
        relativedelta(years=+1)
    possible_property_end_date = datetime.strftime(
        possible_property_end_date, "%d/%m/%Y")

    possible_accessibility_end_date = possible_end_date_as_datetime + \
        relativedelta(years=+11)
    possible_accessibility_end_date = datetime.strftime(
        possible_accessibility_end_date, "%d/%m/%Y")

    past_periods = []

    active_period = Period.objects.currently_active_period()
    periods = Period.objects.all().order_by("-end_date").exclude(id=active_period.id)

    for period in periods:

        if active_period != None:
            past_periods.append(period)

    error = False
    error_message = ""
    if request.POST:

        start_date = datetime.strptime(
            request.POST.get("start_date_picker"), "%d/%m/%Y")
        end_date = datetime.strptime(
            request.POST.get("end_date_picker"), "%d/%m/%Y")
        submission_start_date = datetime.strptime(
            request.POST.get("submission_start_date_picker"), "%d/%m/%Y")
        submission_end_date = datetime.strptime(
            request.POST.get("submission_end_date_picker"), "%d/%m/%Y")
        unit_pi_start_validation_date = datetime.strptime(
            request.POST.get("unit_pi_start_validation_date_picker"), "%d/%m/%Y")
        property_data_end_date = datetime.strptime(
            request.POST.get("property_data_end_date_picker"), "%d/%m/%Y")
        accessibility_data_end_date = datetime.strptime(
            request.POST.get("accessibility_data_end_date_picker"), "%d/%m/%Y")

        # most common check
        if start_date != end_date and end_date > start_date:
            # get all future periods

            future_periods = Period.objects.filter(
                end_date__gte=today).order_by("end_date")

            for future_period in future_periods:

                # check if submitted period isn't covering an existing period

                if start_date.date() < future_period.end_date and end_date.date() > future_period.start_date:
                    error_message = f"Period already covered ({future_period})"
                    error = True
                    break

            if submission_start_date > unit_pi_start_validation_date:
                error_message += f"submission start date ({submission_start_date}) should start before Unit-PI validation date ({unit_pi_start_validation_date})"
                error = True

            if submission_end_date > unit_pi_start_validation_date:
                error_message += f"submission end date ({submission_end_date}) should end before Unit-PI validation date ({unit_pi_start_validation_date})"
                error = True
            if unit_pi_start_validation_date > start_date:
                error_message += f"Unit-PI validation date ({unit_pi_start_validation_date}) should end before period start date ({start_date})"
                error = True
            if property_data_end_date < end_date:
                error_message += f"Property data end date ({property_data_end_date}) should start after period end date ({end_date})"
                error = True
            if accessibility_data_end_date < property_data_end_date:
                error_message += f"Accessibility data end date ({accessibility_data_end_date}) should start after property data end date ({property_data_end_date})"
                error = True

            if not error:
                new_period = Period.objects.create()
                new_period.start_date = start_date
                new_period.end_date = end_date

                new_period.submission_start_date = submission_start_date
                new_period.submission_end_date = submission_end_date
                new_period.unit_pi_validation_start_date = unit_pi_start_validation_date
                new_period.property_of_data_end_date = property_data_end_date
                new_period.data_accessibility_end_date = accessibility_data_end_date

                new_period.save()
                return HttpResponseRedirect(reverse("period_list"))

    return render(request, "scientific_program/create_period.html", {
        "error_message": error_message,
        "error": error,
        "past_periods": past_periods,
        "active_period": active_period,
        "possible_start_date": possible_start_date,
        "possible_end_date": possible_end_date,
        "possible_submission_start_date": possible_submission_start_date,
        "possible_submission_end_date": possible_submission_end_date,
        "possible_validation_start_date": possible_validation_start_date,
        "possible_property_end_date": possible_property_end_date,
        "possible_accessibility_end_date": possible_accessibility_end_date
    })

@login_required

@level_required("Admin", "Unit-PI","Unit-board")

def edit_period(request, id):

    edit = get_object_or_404(Period, pk=id)

    today = timezone.now().date()
    past_periods = []
    active_period = Period.objects.currently_active_period()
    periods = Period.objects.all().order_by("-end_date").exclude(id=active_period.id)
    for period in periods:
        if active_period != None:
            past_periods.append(period)
    error = False
    error_message = ""

    if request.POST:

        start_date = datetime.strptime(
            request.POST.get("start_date_picker"), "%d/%m/%Y")
        end_date = datetime.strptime(
            request.POST.get("end_date_picker"), "%d/%m/%Y")
        submission_start_date = datetime.strptime(
            request.POST.get("submission_start_date_picker"), "%d/%m/%Y")
        submission_end_date = datetime.strptime(
            request.POST.get("submission_end_date_picker"), "%d/%m/%Y")
        unit_pi_start_validation_date = datetime.strptime(
            request.POST.get("unit_pi_start_validation_date_picker"), "%d/%m/%Y")
        property_data_end_date = datetime.strptime(
            request.POST.get("property_data_end_date_picker"), "%d/%m/%Y")
        accessibility_data_end_date = datetime.strptime(
            request.POST.get("accessibility_data_end_date_picker"), "%d/%m/%Y")
        # most common check

        if start_date != end_date and end_date > start_date:

            # get all future periods
            future_periods = Period.objects.filter(

                end_date__gte=today).order_by("end_date").exclude(id=edit.id)

            for future_period in future_periods:
                # check if submitted period isn't covering an existing period
                if start_date.date() < future_period.end_date and end_date.date() > future_period.start_date:
                    error_message = f"Period already covered ({future_period})"
                    error = True
                    break
            if submission_start_date > unit_pi_start_validation_date:
                error_message += f"submission start date ({submission_start_date}) should start before Unit-PI validation date ({unit_pi_start_validation_date})"
                error = True

            if submission_end_date > unit_pi_start_validation_date:
                error_message += f"submission end date ({submission_end_date}) should end before Unit-PI validation date ({unit_pi_start_validation_date})"
                error = True
            if unit_pi_start_validation_date > start_date:
                error_message += f"Unit-PI validation date ({unit_pi_start_validation_date}) should end before period start date ({start_date})"
                error = True
            if property_data_end_date < end_date:
                error_message += f"Property data end date ({property_data_end_date}) should start after period end date ({end_date})"
                error = True
            if accessibility_data_end_date < property_data_end_date:
                error_message += f"Accessibility data end date ({accessibility_data_end_date}) should start after property data end date ({property_data_end_date})"
                error = True
            if not error:

                edit.start_date = start_date
                edit.end_date = end_date
                edit.submission_start_date = submission_start_date
                edit.submission_end_date = submission_end_date
                edit.unit_pi_validation_start_date = unit_pi_start_validation_date
                edit.property_of_data_end_date = property_data_end_date
                edit.data_accessibility_end_date = accessibility_data_end_date
                edit.save()

                return redirect('detail_period', id=id)
            

    return render(request, 'scientific_program/period_detail_edit.html', {
        'id': id,
        'period': edit,
        "error_message": error_message,
        "error": error,
        "past_periods": past_periods,
        "active_period": active_period
    })

@login_required

@level_required("Admin", "Unit-PI", "Unit-board", "Observer")

def detail_period(request, id):

    period = get_object_or_404(Period, pk=id)
    sp_periods = SP_Period.objects.filter(period=period)

    sp_of_user = SP_Period_User.objects.filter(
        user=request.user.id, SP_Period__in=sp_periods)
    today = timezone.now().date()
    is_period_public = period.end_date < today and period.start_date < today

    CAN_VIEW_ALL_SP = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    CAN_VIEW_HIS_SP = request.session.get("role") == "Observer"
    CAN_EDIT_PERIOD = request.session.get("role") in ("Admin","Unit-PI","Unit-board")
    CAN_DELETE_PERIOD = request.session.get("role") in ("Admin","Unit-PI","Unit-board") and not sp_periods

    return render(request, 'scientific_program/period_detail.html', {
        'period': period,
        "sp_periods": sp_periods,
        "sp_of_user": sp_of_user,

        "is_period_public": is_period_public,
        "CAN_VIEW_ALL_SP": CAN_VIEW_ALL_SP,
        "CAN_VIEW_HIS_SP": CAN_VIEW_HIS_SP,
        "CAN_EDIT_PERIOD": CAN_EDIT_PERIOD,
        "CAN_DELETE_PERIOD": CAN_DELETE_PERIOD

    })

@login_required()

@level_required("Admin", "Unit-PI","Unit-board")

def delete_period(request, id):

    period = get_object_or_404(Period, pk=int(id))
    period.delete()
    return HttpResponseRedirect(reverse('period_list'))


@login_required

@level_required("Admin", "Unit-PI", "Observer", "Unit-board")

def period_list(request):

    today = timezone.now().date()
    periods = Period.objects.all().order_by("-end_date")

    future_periods = []
    past_periods = []

    active_period = Period.objects.currently_active_period()

    CAN_ADD_PERIOD = request.session.get("role") in ("Admin","Unit-PI","Unit-board")

    for period in periods:

        if period == active_period:
            future_periods.insert(0, period)

        else:

            if period.start_date >= today and period.end_date >= today:

                future_periods.append(period)
            else:
                past_periods.append(period)

    return render(request, 'scientific_program/periods.html', {
        'past_periods': past_periods,
        "future_periods": future_periods,
        "CAN_ADD_PERIOD": CAN_ADD_PERIOD
    })