from django.core.paginator import Paginator
import pickle
from src.pyros_logger import log
from pprint import pprint
import mimetypes
from django.http import HttpResponse
from django.utils.encoding import smart_str
from wsgiref.util import FileWrapper
from collections import OrderedDict
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from django.shortcuts import get_object_or_404, render, redirect

from common.models import *
from routine_manager.models import *
from django.db.models import Q

from django.contrib.auth.decorators import login_required
from src.core.pyros_django.dashboard.decorator import level_required
import ast
import os
import datetime

from django.forms.models import model_to_dict
from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig

from .forms import SequenceForm, AlbumForm, PlanForm, uneditablePlanForm
#from .forms import RequestForm, SequenceForm, AlbumForm, PlanForm, uneditablePlanForm

from .validators import check_plan_validity, check_album_validity, check_sequence_validity, check_request_validity
from .functions import check_sequence_file_validity_and_save
from .RequestSerializer import RequestSerializer
import scheduler
from django.contrib import messages
from django.http import JsonResponse
""" logger """
from django.conf import settings
# "import utils.Logger as l
# "log = l.setupLogger("routine_manager-views", "routine_manager-views")

import yaml
import json
""" XML Export / Import utils """
SAVED_REQUESTS_FOLDER = "misc/saved_requests/"


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def sequences_list(request, status=0, message="", import_response=None):
    """
        Retrieves and display the routines list (routine manager main page)
    """

    if settings.DEBUG:
        #log.info("From sequences_list")
        pass

    if status == "-1":
        error = True
    elif status == "1":
        success = True

    # TODO: uncomment for alert filter
#     requests_objs = Request.objects.filter(pyros_user=request.user).filter(is_alert=False).order_by("-updated")
    sp_of_user = request.user.get_scientific_program()
    sequences_objs = Sequence.objects.filter(scientific_program__in=sp_of_user).order_by("-updated")
    #sp_where_user_is_sp_pi = request.user.get_scientific_program_where_user_is_sp_pi()
    #sequences_objs = Sequence.objects.filter(
    #    pyros_user=request.user).order_by("-updated")
    # if sp_where_user_is_sp_pi.count() > 0:
    #     sequences_objs = sequences_objs | Sequence.objects.filter(
    #         scientific_program__in=sp_where_user_is_sp_pi).order_by("-updated")
    sequences = []
    if request.session.get("role") in ("Admin", "Unit-PI"):
        sequences_objs = Sequence.objects.all().order_by("-updated")
    paginator = Paginator(sequences_objs, settings.NB_ELEMENT_PER_PAGE)
    page_number = request.GET.get("page")
    page_obj = paginator.get_page(page_number)
    for seq in page_obj:
        nb_album = Album.objects.filter(sequence=seq).count
        nb_plan = Plan.objects.filter(
            album__in=Album.objects.filter(sequence=seq).values("id")).count
        sequences.append(
            {"seq": seq, "nb_album": nb_album, "nb_plan": nb_plan})

    #print("REQ/views: Les requetes sont:")
    # requests_objs = Request.objects.filter(pyros_user=request.user).order_by("-updated")
    # print("REQ/views: Les requetes sont:")

    # requests = []

    # for req in requests_objs:
    #     #print("- REQ/views: requete", req)
    #     sequences = req.sequences
    #     nb_executed = sequences.filter(status=Sequence.EXECUTED).count
    #     nb_cancelled = sequences.filter(Q(status=Sequence.INVALID) | Q(status=Sequence.CANCELLED)
    #                                     | Q(status=Sequence.UNPLANNABLE)).count()
    #     requests.append({'req': req, 'nb_seq': sequences.count(), 'nb_executed': nb_executed, 'nb_cancelled': nb_cancelled})
    print("REQ/views: ICI:")
    # opens template src/routine_manager/templates/routine_manager/sequences_list.html with all local variables
    return render(request, "routine_manager/sequences_list.html", locals())


@login_required
def action_request(request, req_id, action, status=0, message=""):
    """
        Apply actions (view, edit, delete) on a given request
    """

    req = Request.objects.get(id=req_id)
    depth_level = 1

    if settings.DEBUG:
        #log.info("From action_request")
        pass

    if status == "-1":
        error = True
    elif status == "1":
        success = True

    if req.submitted == True and action == "edit":
        error = True
        message = "You can't edit a submitted request"
        action = "view"

    if check_request_validity(req) == True:
        return redirect(unsubmit_request, req_id)
    if action == "edit":
        form = RequestForm(instance=req)
        edit = True
        return render(request, "routine_manager/view_request.html", locals())
    elif action == "view":
        form = RequestForm(instance=req, readonly=True)
        edit = False
        return render(request, "routine_manager/view_request.html", locals())
    elif action == "delete":
        req.delete()
        return redirect(sequences_list, status='1', message="Successfully deleted the request")

    return redirect(sequences_list)


@login_required
def request_validate(request, req_id):
    """
        Called when the request form was validated.
        Possible actions : Cancel, Save, Save and add sequence, Delete
    """

    action = request.POST.get("action")
    req = Request.objects.get(id=req_id)
    form = RequestForm(instance=req, data=request.POST)

    if (settings.DEBUG):
        #log.info("From request_validate")
        pass

    if action == "cancel":
        if req.name == "New request":
            req.delete()
        return redirect(sequences_list, status=1, message="Cancelled request modification")
    elif action == "delete":
        return redirect(action_request, req_id, "delete")
    elif form.is_valid():
        req = form.save()
        if action == "save":
            return redirect(action_request, req_id=req_id, action="edit", status=1, message="Request saved")
        if action == "save_and_add":
            return redirect(create_sequence, req_id=req_id)
    else:
        error = True
        message = "Please check your field's validity"
        depth_level = 1
        edit = True
        return render(request, "routine_manager/view_request.html", locals())


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def action_sequence(request, seq_id, action, status=0, message=""):
    """
        Apply actions (view, edit, delete) on a given sequence
    """
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    seq_id = int(seq_id)
    seq = Sequence.objects.get(id=seq_id)
    depth_level = 1

    if (settings.DEBUG):
        #log.info("From action_sequence")
        pass

    if status == "-1":
        error = True
    elif status == "1":
        success = True
    if seq.status != Sequence.DRAFT and action == "edit":
        pass
        # error = True
        # message = "You can't edit a submitted request"
        # messages.add_message(
        #     request, messages.WARNING, "You can't edit a submitted request")
        # action = "view"

    horizon_line = config.getHorizonLine(config.unit_name)
    horizon_line_svg = f'<svg id="horizonline" width="30vw" height="5vh">\
    <line x1="{horizon_line[0][0]}" y1="{horizon_line[0][1]}" x2="{horizon_line[1][0]}" y2="{horizon_line[1][1]}" stroke="black" fontsize="2em"/>\
    </svg><p> (values : {horizon_line})</p>'
    if request.session.get("role") in ("Admin", "Unit-PI"):
        sp_list = ScientificProgram.objects.observable_programs()
    else:
        sp_of_user = request.user.get_scientific_program()
        sp_list = ScientificProgram.objects.observable_programs().filter(id__in=sp_of_user)
    if seq.pyros_user != None and seq.scientific_program != None and request.session.get("role") == "Observer" and seq.scientific_program not in sp_of_user:
        messages.add_message(
            request, messages.INFO, "You can't acces to this page because this sequence is linked to a scientific program that you aren't part of")
        return redirect(sequences_list)
    if action == "edit":
        if len(sp_list) == 0:
            messages.add_message(
                request, messages.INFO, "Can't submit a Sequence : there is no scientific program to be assigned with")
            return redirect(sequences_list)
        form = SequenceForm(instance=seq, data_from_config=config.getEditableAttributesOfMount(
            config.unit_name), layouts=config.get_layouts(config.unit_name), sp_list=sp_list)
        edit = True
        return render(request, "routine_manager/view_sequence.html", locals())
    elif action == "view":
        form = SequenceForm(instance=seq, data_from_config=config.getEditableAttributesOfMount(
            config.unit_name), layouts=config.get_layouts(config.unit_name), sp_list=sp_list, readonly=True)
        edit = False
        return render(request, "routine_manager/view_sequence.html", locals())
    elif action == "delete":
        if seq.status in (Sequence.DRAFT, Sequence.TOBEPLANNED):
            log.info(
                f"User {request.user} did action delete sequence {seq.name}")
            seq.delete()
            # if check_sequence_validity(seq) == True:
            # return redirect(unsubmit_request, req_id)
            return redirect(sequences_list)

    return redirect(sequences_list)


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def unsubmit_sequence(request, seq_id):
    seq = Sequence.objects.get(id=int(seq_id))
    status = seq.status 
    message = ""
    if status == Sequence.TOBEPLANNED:
        seq.status = Sequence.DRAFT
        seq.save()
        message = "Sequence unsubmitted"
    else:
        message = "The sequence isn't submitted."
    messages.add_message(request,messages.INFO,message)
    return redirect(action_sequence, seq_id, "view")
    
def create_sequence_pickle(sequence):
    seq_dict = model_to_dict(sequence)
    fullseq_dict = {
        "sequence":seq_dict,
        "albums": {}
    }
    for album in sequence.albums.all():
        fullseq_dict["albums"][album.name] = {"plans" : []}
        for plan in album.plans.all():
            fullseq_dict["albums"][f"{album.name}"]["plans"].append(model_to_dict(instance=plan))
    period = sequence.period
    if not os.path.exists("sequences_pickle"):
        os.mkdir("./sequences_pickle")
    if not os.path.exists(f"sequences_pickle/P{period.id}"):
        os.mkdir(f"sequences_pickle/P{period.id}")
    seq_pickle_file_name = f"./sequences_pickle/P{period.id}/{sequence.name}.p"
    pickle.dump(fullseq_dict,open(seq_pickle_file_name,"wb"))

@login_required
@level_required("Admin", "Unit-PI", "Observer")
def sequence_validate(request, seq_id):
    """
        Called when the sequence form was validated.
        Possible actions : Cancel, Save, Save and add album, Delete
    """

    if (settings.DEBUG):
        #log.info("From sequence_validate")
        pass
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    seq_id = int(seq_id)
    action = request.POST.get("action")
    seq = Sequence.objects.get(id=seq_id)
    form = SequenceForm(instance=seq, data=request.POST, data_from_config=config.getEditableAttributesOfMount(
        config.unit_name), layouts=config.get_layouts(config.unit_name))
    seq.last_modified_by = request.user
    seq.save()
    if action == "cancel":
        seq.delete()
        return redirect(sequences_list)
    elif action == "delete":
        return redirect(action_sequence, seq_id, "delete")
    elif action == "check_validity":
        seq.save()
        is_seq_valid = check_sequence_validity(seq)
        for album in Album.objects.filter(sequence=seq):
            for plan in Plan.objects.filter(album=album):
                check_plan_validity(plan)
        message = ""
        if is_seq_valid == True:
            message = f"The sequence is valid and can be submitted."
        else:
            message = f"The sequence isn't valid. Check if your sequence have, at least, an album and that album has one plan at minimum.\
                Each album needs at least one plan."
        messages.add_message(request, messages.INFO, message)
        return redirect(action_sequence, seq_id, "edit")
    elif form.is_valid():
        seq = form.save()
        if action == "save":
            message = "Sequence saved"
            messages.add_message(request, messages.INFO, message)
            return redirect(sequences_list, status=1, message="Sequence saved")
            # return redirect(action_sequence, seq_id=seq_id, action="edit", status=1, message="Sequence saved")
        elif action == "save_and_do_nothing":
            return redirect(action_sequence, seq_id=seq_id, action="edit", status=1, message="Sequence saved")
        if action == "save_and_add":
            albums = config.getLayoutByName(
                unit_name=config.unit_name, name_of_layout=seq.config_attributes["layout"])["ALBUMS"]
            for album_name in albums:
                album_desc = config.getAlbumByName(
                    config.unit_name, album_name).get("description", "")
                create_album(request, seq_id,
                             album_name=album_name, desc=album_desc)
            # return redirect(create_album, seq_id=seq_id)
            messages.add_message(request, messages.INFO,
                                 "Created albums according to chosen layouts")
            return redirect(action_sequence, seq.id, "edit")
        if action == "save_and_submit":
            if check_sequence_validity(seq):
                seq.status = Sequence.TOBEPLANNED
                seq.save()
                message = "Sequence submitted"
                create_sequence_pickle(seq)
                messages.add_message(request, messages.INFO, message)
                log.info(
                    f"User {request.user} did action submit sequence {seq} for period {seq.period} ")
                return redirect(sequences_list)
            else:
                message = "Can't submit sequence because it's incomplete (Need at least 1 album with 1 plan)"
                messages.add_message(request, messages.ERROR, message)
                status = 1
                edit = True
                return render(request, "routine_manager/view_sequence.html", locals())
    else:
        error = True
        message = "Please check your field's validity"
        depth_level = 1
        edit = True
        return render(request, "routine_manager/view_sequence.html", locals())


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def action_album(request, alb_id, action, status=0, message=""):
    """
        Apply actions (view, edit, delete) on a given album
    """
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)

    alb_id = int(alb_id)
    alb = Album.objects.get(id=alb_id)
    seq_id = alb.sequence.id
    depth_level = 2
    seq = alb.sequence
    if (settings.DEBUG):
        #log.info("From action_album")
        pass

    if status == "-1":
        error = True
    elif status == "1":
        success = True

    if alb.sequence.status != Sequence.DRAFT and action == "edit":
        error = True
        message = "You can't edit a submitted request"
        action = "view"

    # if check_album_validity(alb) == True:
        # return redirect(unsubmit_request, req_id)
        # pass
    if action == "edit":
        form = AlbumForm(instance=alb, readonly=True)
        edit = True
        return render(request, "routine_manager/view_album.html", locals())
    elif action == "view":
        form = AlbumForm(instance=alb, readonly=True)
        edit = False
        return render(request, "routine_manager/view_album.html", locals())
    elif action == "delete":
        log.info(
            f"User {request.user} did action delete Album {alb.name} of Sequence {seq}")
        alb.delete()
        return redirect(action_sequence, seq_id=alb.sequence.id, action="edit", status='1', message="Successfully deleted the album")

    return redirect(sequences_list)


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def album_validate(request, alb_id):
    """
        Called when the album form was validated.
        Possible actions : Cancel, Save, Save and add plan, Delete
    """
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    alb_id = int(alb_id)
    action = request.POST.get("action")
    alb = Album.objects.get(id=alb_id)
    form = AlbumForm(instance=alb, data=request.POST)
    alb.sequence.last_modified_by = request.user
    alb.sequence.save()
    if (settings.DEBUG):
        #log.info("From album_validate")
        pass

    if action == "cancel":
        alb.delete()
        return redirect(action_sequence, seq_id=alb.sequence.id, action="edit", status='1', message="Cancelled album modification")
    elif action == "delete":
        return redirect(action_album, alb_id, "delete")
    elif form.is_valid():
        alb = form.save()
        if action == "save":
            return redirect(action_sequence, seq_id=alb.sequence.id, action="edit")
            # return redirect(action_album, alb_id=alb_id, action="edit", status=1, message="Album saved")
        if action == "save_and_add":
            return redirect(create_plan, alb_id=alb_id)
    else:
        error = True
        message = "Please check your field's validity"
        depth_level = 2
        edit = True
        seq_id = alb.sequence.id
        action = "edit"
        return render(request, "routine_manager/view_album.html", locals())


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def action_plan(request, plan_id, action, status=0, message=""):
    """
        Apply actions (view, edit, delete) on a given plan
    """
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    plan_id = int(plan_id)
    plan = Plan.objects.get(id=plan_id)
    album_name = plan.album.name
    channel = config.getAlbumByName(
        config.unit_name, album_name)["CHANNELS"][0]
    data_from_config = config.getEditableAttributesOfChannel(
        config.unit_name, channel)
    seq_id = plan.album.sequence.id
    seq = plan.album.sequence
    alb_id = plan.album.id
    depth_level = 3
    # get index of plan within the album. Adding one for human comprehension
    index_of_plan_in_album = list(plan.album.plans.all(
    ).values_list("id", flat=True)).index(plan.id) + 1
    if (settings.DEBUG):
        #log.info("From action_plan")
        pass

    if status == "-1":
        error = True
    elif status == "1":
        success = True

    if plan.album.sequence.status != Sequence.DRAFT and action == "edit":
        error = True
        message = "You can't edit a submitted sequence"
        action = "view"

    if action == "edit":
        form = PlanForm(edited_plan=plan, data_from_config=data_from_config)
        uneditableForm = uneditablePlanForm(
            data_from_config=config.getUneditableAttributesOfChannel(config.unit_name, channel))
        edit = True
        return render(request, "routine_manager/view_plan.html", locals())
    elif action == "view":
        form = PlanForm(edited_plan=plan,
                        data_from_config=data_from_config, readonly=True)
        uneditableForm = uneditablePlanForm(
            data_from_config=config.getUneditableAttributesOfChannel(config.unit_name, channel))
        edit = False
        return render(request, "routine_manager/view_plan.html", locals())
    elif action == "delete":
        log.info(
            f"User {request.user} did action delete Plan {plan.id} of Sequence {seq}")
        plan.delete()
        check_sequence_validity(seq)
        check_album_validity(plan.album)
        return redirect(action_album, alb_id=plan.album.id, action="edit", status='1', message="Successfully deleted the plan")

    return redirect(sequences_list)


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def plan_validate(request, plan_id):
    """
        Called when the plan form was validated.
        Possible actions : Cancel, Save, Delete
    """
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    plan_id = int(plan_id)
    action = request.POST.get("action")
    plan = Plan.objects.get(id=plan_id)
    seq = plan.album.sequence
    seq.last_modified_by = request.user
    seq.save()
    # name_of_channel_group = plan.album.name_of_channel_group
    # channel = None
    # if name_of_channel_group == "All":
    #     channel = config.getLayoutByName(config.unit_name,config.get_layouts(config.unit_name)["groups"][0]["name"])
    # else:
    #     # we retrieve config of the first channel of the group
    #     channel = config.getLayoutByName(config.unit_name,name_of_channel_group)["channels"][0]
    album_name = plan.album.name
    channel = config.getAlbumByName(
        config.unit_name, album_name)["CHANNELS"][0]
    data_from_config = config.getEditableAttributesOfChannel(
        config.unit_name, channel)
    #form = PlanForm(instance=plan, data=request.POST)
    form = PlanForm(edited_plan=plan, data_from_config=data_from_config)

    if (settings.DEBUG):
        #log.info("From plan_validate")
        pass
    if action == "cancel":

        plan.delete()
        return redirect(action_album, alb_id=plan.album.id, action="edit", status='1', message="Cancelled plan modification")
    elif action == "delete":
        return redirect(action_plan, plan_id, "delete")
    elif form.is_valid():
        # unused
        plan = form.save()
        if action == "save":
            action = "edit"
            status = 1
            message = "Plan saved"
            return redirect(action_plan, locals())
    elif action == "save":
        if request.POST:

            post_data = request.POST.copy()
            if post_data.get("csrfmiddlewaretoken"):
                post_data.pop("csrfmiddlewaretoken")
            post_data.pop("action")
            nb_images = post_data.pop("nb_images")[0]
            config_attributes = {}
            for key, value in post_data.items():
                if type(value) == str:
                    try:
                        # linked values
                        new_dict = {key: {}}
                        splitted_values = value.split(";")
                        config_attributes[key] = {}
                        for splitted_value in splitted_values:
                            subkey, subvalue = splitted_value.split(":")
                            config_attributes[key][subkey] = ast.literal_eval(
                                subvalue)
                    except:
                        # Do nothing, normal string
                        config_attributes[key] = ast.literal_eval(value)
            plan.nb_images = int(nb_images)
            plan.config_attributes = config_attributes
            plan.save()
            # if check_plan_validity(plan) == True:
            # return redirect(unsubmit_request, req_id)
            # pass
            return redirect(action_album, plan.album.id, "edit")
            # return redirect(action_plan, plan_id, "edit", 1, "Plan saved")
    else:
        error = True
        message = "Please check your field's validity"
        edit = True
        seq_id = plan.album.sequence.id
        alb_id = plan.album.id
        depth_level = 3
        return render(request, "routine_manager/view_plan.html", locals())


@login_required
def create_request(request):
    """
        Create a new request and redirects to the editing action on it
    """

    req = Request.objects.create(pyros_user=request.user, name="New request",
                                 is_alert=False, autodeposit=False, complete=False, submitted=False)
    return redirect(action_request, req.id, "edit")


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def create_sequence(request):
    """
        Create a new sequence and redirects to the editing action on it
    """
    date_of_sequence = datetime.datetime.utcnow()
    date_of_sequence = date_of_sequence.strftime("%Y%m%dT%H%M%S")
    sp_of_user = request.user.get_scientific_program()
    sp_list = ScientificProgram.objects.observable_programs().filter(id__in=sp_of_user)
    if len(sp_list) == 0:
        messages.add_message(
            request, messages.INFO, "Can't submit a Sequence : there is no scientific program to be assigned with")
        return redirect(sequences_list)
    seq = Sequence.objects.create(
        pyros_user=request.user, name=f"seq_{str(date_of_sequence)}", status=Sequence.DRAFT)
    log.info(f"User {request.user} did action create Sequence {seq.name}")
    return redirect(action_sequence, seq.id, "edit")


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def create_album(request, seq_id, album_name, desc):
    """
        Create a new album and redirects to the editing action on it
    """

    seq = Sequence.objects.get(id=seq_id)
    alb = Album.objects.create(
        sequence=seq, name=album_name, desc=desc, complete=False)
    log.info(
        f"User {request.user} did action create Album {alb.id} of Sequence {seq.name}")
    # return redirect(action_album, alb.id, "edit")


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def create_plan(request, alb_id):
    """
        Create a new plan and redirects to the editing action on it
    """

    alb = Album.objects.get(id=alb_id)
    plan = Plan.objects.create(album=alb, nb_images=1)
    log.info(
        f"User {request.user} did action create Plan {plan.id} of Sequence {plan.album.sequence.name}")
    return redirect(action_plan, plan.id, "edit")


@login_required
def submit_request(request, req_id, redir):
    """
        Submits a request and its sequences for scheduling
    """

    if (settings.DEBUG):
        pass
        log.info("From submit_request")

    req = Request.objects.get(id=req_id)
    error = False
    if req.complete == False:
        error = True
        message = "A request must be complete to be submitted"
    elif req.submitted == True:
        error = True
        message = "The request is already submitted"

    if error == True:
        return redirect(action_request, req_id=req_id, action="view", status=-1, message=message)

    for seq in req.sequences.all():
        seq.status = Sequence.TOBEPLANNED
        seq.save()
    req.submitted = True
    req.save()

    # TODO : changer le first_schedule ...
    '''
    if settings.USE_CELERY:
        print("WITH CELERY")
        scheduler.tasks.scheduling.delay(first_schedule=True, alert=False)
    else:
    '''
    print("Change 1st schedule")
    scheduler.tasks.scheduling().run(first_schedule=True, alert=False)

    message = "The request was submitted"
    if redir == "action_request":
        return redirect(action_request, req_id=req_id, action="view", status=1, message=message)
    else:
        return redirect(sequences_list, status=1, message=message)


@login_required
def unsubmit_request(request, req_id):
    """
        Unsubmits a request and remove its sequences from scheduling
    """

    if (settings.DEBUG):
        pass
        log.info("From unsubmit_request")

    req = Request.objects.get(id=req_id)

# TODO: uncomment pour la production
#     if req.sequences.filter(Q(status=Sequence.EXECUTED) | Q(status=Sequence.EXECUTING)).exists():
#         message = "You can't unsubmit a request with executed sequences"
#         return redirect(action_request, req_id=req_id, action="view", status=-1, message=message)

    req.submitted = False
    req.save()
    sequences = req.sequences.filter(Q(status=Sequence.TOBEPLANNED) | Q(status=Sequence.PLANNED) |
                                     Q(status=Sequence.INVALID) | Q(status=Sequence.UNPLANNABLE))
    for seq in sequences:
        seq.status = Sequence.COMPLETE
        seq.save()
    # TODO: uncomment
    # scheduler.tasks.scheduling.delay(first_schedule=True, alert=False)  # TODO : changer le first_schedule ...

    if req.complete == True:
        message = "The request was unsubmitted"
    else:
        message = "The request was unsubmitted because it is incomplete"
    return redirect(action_request, req_id=req_id, action="edit", status=1, message=message)


@login_required
def export_request(request, req_id):
    """
        Create an XML file with the given request, and send a download request to the user
    """

    if (settings.DEBUG):
        #log.info("From export_request")
        pass

    req = Request.objects.get(id=req_id)
    if req.complete == False:
        message = "Request must be completely valid to be serialized"
        return redirect(action_request, req_id=req_id, action="view", status=-1, message=message)

    file_name = SAVED_REQUESTS_FOLDER + "request" + str(req.id) + ".xml"
    rs = RequestSerializer()
    rs.serialize(req, file_name)

    wrapper = FileWrapper(open(file_name, "r"))
    content_type = mimetypes.guess_type(file_name)[0]

    response = HttpResponse(wrapper, content_type=content_type)
    response['Content-Length'] = os.path.getsize(file_name)
    response['Content-Disposition'] = 'attachment; filename=%s' % smart_str(
        os.path.basename(file_name))

    return response


@login_required
@csrf_exempt
def import_request(request):
    """
        Ask for a XML file, parse it and create a request in DB
        Don't do anything if there is a single error into the file
    """

    if (settings.DEBUG):
        pass
        #log.info("From import_request")

    log.info(request)

    if request.method == "POST":
        file = request.FILES.get("request_file")
        if file is None:
            status = -1
            message = "File does not exist"
        elif file.size > 1000000:
            status = -1
            message = "File is too big (more than 1 000 000 bytes)"
        else:
            rs = RequestSerializer()
            message = rs.unserialize(file.read(), request.user)
            if message != "":
                status = -1
            else:
                status = 1
                message = "Request imported successfully. Please check it before submitting for scheduling."
        print("message is", message)
    else:
        status = -1
        message = "Internal error"

    # Now, display the list of requests (updated with this new request)
    return redirect(sequences_list, status=status, message=message)

# @login_required
# def test_create_plan(request):
#     config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"],os.environ["unit_name"])
#     if request.POST:

#         post_data = request.POST.copy()
#         post_data.pop("csrfmiddlewaretoken")
#         nb_images = post_data.pop("nb_images")[0]
#         config_attributes = {}
#         for key,value in post_data.items():
#             if type(value) == str:
#                 try:
#                     # linked values
#                     new_dict = {key:{}}
#                     splitted_values = value.split(";")
#                     config_attributes[key] = {}
#                     for splitted_value in splitted_values:
#                         subkey,subvalue = splitted_value.split(":")
#                         config_attributes[key][subkey] = ast.literal_eval(subvalue)
#                 except:
#                     # Do nothing, normal string
#                     config_attributes[key] = ast.literal_eval(value)
#         plan = Plan()
#         plan.nb_images = int(nb_images)
#         plan.config_attributes = config_attributes
#         plan.save()
#     form = PlanForm(data_from_config=config.getEditableAttributesOfChannel(config.unit_name,list(config.get_channels(config.unit_name).keys())[0]))
#     uneditableForm = uneditablePlanForm(data_from_config=config.getUneditableAttributesOfChannel(config.unit_name,list(config.get_channels(config.unit_name).keys())[0]))
#     return render(request,"routine_manager/testcreateplan.html",{"form":form,"uneditableForm":uneditableForm})


@login_required
@csrf_exempt
@level_required("Admin", "Unit-PI", "Observer")
def import_sequence(request):
    """
        Ask for a YAML file, parse it and create a request in DB
        Returns a JSON that contains at least, success boolean and errors if this boolean is false
    """
    if request.method == "POST":
        file = request.FILES.get("sequence_file")
        status = 0
        if file is None:
            status = -1
            message = "File does not exist"
        elif file.size > 1000000:
            status = -1
            message = "File is too big (more than 1 000 000 bytes)"
        else:
            yaml_content = yaml.safe_load(file.read())
            import_response = check_sequence_file_validity_and_save(
                yaml_content, request)
            if import_response["succeed"]:
                message = "Request imported successfully. Please check it before submitting for scheduling."
            else:
                message = "Failed to import, check errors"
        print("message is", message)
    else:
        status = -1
        message = "Internal error"
    return JsonResponse(import_response)
    # Now, display the list of requests (updated with this new request)
    return redirect(sequences_list, status=status, message=message, import_response=import_response)


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def export_sequence(request, seq_id: int, type: str):
    sp_of_user = request.user.get_scientific_program()
    sp_list = ScientificProgram.objects.observable_programs().filter(id__in=sp_of_user)
    seq = Sequence.objects.get(id=seq_id)
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    sequence_form = SequenceForm(instance=seq, data_from_config=config.getEditableAttributesOfMount(
        config.unit_name), layouts=config.get_layouts(config.unit_name), sp_list=sp_list)
    yaml_dict = {
        "sequence": {}
    }

    for field in sequence_form.fields.keys():
        if sequence_form.fields[field].required == False:
            continue
        field_dict = {"editable": True}
        if field == "scientific_program":
            sp_list = list(sp_list.values_list("name", flat=True))
            field_dict["value"] = sp_list.index(seq.scientific_program.name)
            field_dict["values"] = sp_list
            field_dict["value_type"] = "int"

        elif field == "start_date":
            #field_dict["value"] = seq.start_date.strftime("%d/%m/%Y %H:%M:%S")
            # ISO format
            field_dict["value"] = seq.start_date.strftime("%Y-%m-%dT%H:%M:%S.%f")
            field_dict["value_type"] = "str"
        else:
            if hasattr(sequence_form.fields[field].widget,"input_type"):
                field_dict["value_type"] = sequence_form.fields[field].widget.input_type
            else:
                field_dict["value_type"] = "str"
            if seq.__dict__.get(field) == None:
                value = seq.config_attributes.get(field)
            else:
                value = seq.__dict__.get(str(field))
            field_dict["value"] = value
            if sequence_form.fields[field].__dict__.get("_choices"):
                field_dict["value_type"] = "int"
                field_dict["values"] = [
                    value[0] for value in sequence_form.fields[field].__dict__.get("_choices")]
                field_dict["value"] = field_dict["values"].index(value)
            if field == "layout":
                field_dict["editable"] = False
            if type == "template" and field != "layout":
                field_dict["value"] = None
            if sequence_form.fields[field].__dict__.get("min_value"):
                field_dict["min_value"] = sequence_form.fields[field].__dict__.get(
                    "min_value")
            if sequence_form.fields[field].__dict__.get("max_value"):
                field_dict["max_value"] = sequence_form.fields[field].__dict__.get(
                    "max_value")
        yaml_dict["sequence"][field] = field_dict
    album_list = []
    for album in seq.albums.all():
        album_dict = {
            "Album": {
                "name": album.name
            }
        }
        plans_list = []
        for plan in album.plans.all():
            plan_form = PlanForm(data_from_config=config.getEditableAttributesOfChannel(
                config.unit_name, list(config.get_channels(config.unit_name).keys())[0]), edited_plan=plan)
            plan_dict = {"Plan": {}}
            for field in plan_form.fields.keys():
                field_dict = {}
                if field == "nb_images":
                    field_dict["value"] = plan.nb_images
                    field_dict["value_type"] = "int"
                    field_dict["min_value"] = 1
                else:
                    if plan_form.fields[field].__dict__.get("_choices"):
                        value = plan.config_attributes.get(field)
                        field_dict["value_type"] = "int"
                        field_dict["values"] = [
                            value[0] for value in plan_form.fields[field].__dict__.get("_choices")]
                        container_value_to_str = ""
                        for subkey in value.keys():
                            container_value_to_str += f"{subkey}:{value[subkey]};"
                        container_value_to_str = container_value_to_str[:-1]
                        field_dict["value"] = field_dict["values"].index(
                            container_value_to_str)
                    else:
                        value = plan.config_attributes.get(field)
                        field_dict["value"] = value
                        if plan_form.fields[field].__dict__.get("min_value"):
                            field_dict["min_value"] = plan_form.fields[field].__dict__.get(
                                "min_value")
                        if plan_form.fields[field].__dict__.get("max_value"):
                            field_dict["max_value"] = plan_form.fields[field].__dict__.get(
                                "max_value")
                        field_dict["value_type"] = plan_form.fields[field].widget.input_type
                if type == "template":
                    field_dict["value"] = None
                plan_dict["Plan"][field] = field_dict
            plans_list.append(plan_dict)
        album_dict["Album"]["Plans"] = plans_list
        album_list.append(album_dict)

    yaml_dict["sequence"]["ALBUMS"] = album_list
    response = HttpResponse(
        yaml.dump(yaml_dict, sort_keys=False), content_type='application/yaml')
    response['Content-Disposition'] = 'attachment; filename="{}_{}.yml"'.format(
        seq.name, type)

    return response


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def create_albums(request, seq_id, layout):
    seq = Sequence.objects.get(id=seq_id)
    unit_name = os.environ["unit_name"]
    config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
    albums = config.getLayoutByName(
        unit_name=config.unit_name, name_of_layout=layout)["ALBUMS"]
    for album_name in albums:
        album_desc = config.getAlbumByName(
            config.unit_name, album_name).get("description", "")
        create_album(request, seq_id, album_name=album_name, desc=album_desc)
        # return redirect(create_album, seq_id=seq_id)
    messages.add_message(request, messages.INFO,
                         "Created album(s) according to chosen layout")
    return HttpResponse("ok")


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def delete_albums(request, seq_id):
    seq = Sequence.objects.get(id=seq_id)
    albums = Album.objects.filter(sequence=seq).delete()
    seq.complete = False
    seq.save()
    return HttpResponse(albums)


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def edit_plan(request, id):
    plan = get_object_or_404(Plan, pk=id)
    config = OBSConfig(
        os.environ["PATH_TO_OBSCONF_FILE"], os.environ["unit_name"])
    if request.POST:

        post_data = request.POST.copy()
        post_data.pop("csrfmiddlewaretoken")
        nb_images = post_data.pop("nb_images")[0]
        config_attributes = {}
        for key, value in post_data.items():
            if type(value) == str:
                try:
                    # linked values
                    new_dict = {key: {}}
                    splitted_values = value.split(";")
                    config_attributes[key] = {}
                    for splitted_value in splitted_values:
                        subkey, subvalue = splitted_value.split(":")
                        config_attributes[key][subkey] = ast.literal_eval(
                            subvalue)
                except:
                    # Do nothing, normal string
                    config_attributes[key] = ast.literal_eval(value)
        plan.nb_images = int(nb_images)
        plan.config_attributes = config_attributes
        plan.save()
    form = PlanForm(data_from_config=config.getEditableAttributesOfChannel(
        config.unit_name, list(config.get_channels(config.unit_name).keys())[0]), edited_plan=plan)
    uneditableForm = uneditablePlanForm(data_from_config=config.getUneditableAttributesOfChannel(
        config.unit_name, list(config.get_channels(config.unit_name).keys())[0]))
    return render(request, "routine_manager/testcreateplan.html", {"form": form, "uneditableForm": uneditableForm})


@login_required
@level_required("Admin", "Unit-PI", "Observer")
def copy_sequence(request, seq_id):
    sequence_to_be_copied = Sequence.objects.get(id=seq_id)
    original_sequence = Sequence.objects.get(id=seq_id)
    new_seq = sequence_to_be_copied
    date_of_sequence = datetime.datetime.utcnow()
    date_of_sequence = date_of_sequence.strftime("%Y%m%dT%H%M%S")
    name = f"seq_{str(date_of_sequence)}"
    new_seq.name = name
    new_seq.pk = None
    new_seq._state.adding = True
    new_seq.pyros_user = request.user
    new_seq.complete = False
    new_seq.status = Sequence.DRAFT
    new_seq.save()
    for album in original_sequence.albums.all():
        original_plans_of_album = Album.objects.get(id=album.id).plans.all()
        new_alb = album
        new_alb.complete = False
        new_alb.pk = None
        new_alb.sequence = new_seq
        new_alb._state.adding = True
        new_alb.save()
        for plan in original_plans_of_album:
            new_plan = plan
            new_plan.album = new_alb
            new_plan.complete = False
            new_plan.pk = None
            new_plan._state.adding = True
            new_plan.save()
    return redirect(action_sequence, new_seq.id, "edit")