from __future__ import absolute_import

from django.conf import settings

from common.models import *

from celery.task import Task

import scheduler.tasks
import alert_manager.tasks
import observation_manager.tasks
import time

from devices.PLC import PLCController

import time

TIMER_CHECK = 10  # in seconds

'''
    Infinite task created at the program's start.
    It initilize all the external connections, and starts the alert_listener.

    This is the place to put the starting configurations.

    Once the starting configurations are done, it becomes a loop that checks the PLC and instruments status.
    It also handles the beginning and the end of the night, recalculating them at each end of night.
'''
class monitoring(Task):

    def run(self):

        self.setContext()

        self.get_night_start_end()

        alert_manager.tasks.alert_listener.delay()

        self.timers_loop()

    '''
        Creates the communication objects for each instrument, and give them the basic configurations.
    '''
    def setContext(self):

        self.plc = PLCController()

        return (0)

    def timers_loop(self):
        '''
            Infinite loop for the different timers :
                - Every TIMER_CHECK seconds, check PLC and instruments status (+ analyse them and send them to the IC)
                - 2 minutes before the night start, make a scheduling

                - At the end of the night, do calibration files and computes the next night limits + make a scheduling with the new schedule

        '''

        timer_status = TIMER_CHECK

        ''' Set night start timer to 1 day, then compute the real ones if the current time isn't during the night '''
        timer_night_start = 86400

        night_start_seconds = self.night_start * 3600 * 24
        night_end_seconds = self.night_end * 3600 * 24

        if night_start_seconds - 120 > time.time():
            timer_night_start = night_start_seconds - 120 - time.time()

        timer_night_end = night_end_seconds - time.time()

        timers = {"status": timer_status, "night_start": timer_night_start, "night_end": timer_night_end}

        while True:
            minimal_timer = min(timers, key=timers.get)
            ''' Wait for the nearest timer '''
            time.sleep(timers[minimal_timer])
            ''' Update the timers '''
            timers = {key: value - timers[minimal_timer] for key, value in timers.items()}

            ''' Then check what timers are <= 0 '''
            for timer_name, timer_value in timers.items():
                if timer_value <= 0:
                    if timer_name == "status":

                        status_tel = self.tel.get("STATUS")
                        status_nir = self.nir_camera.get("STATUS")
                        status_vis = self.vis_camera.get("STATUS")

                        status_plc = self.plc.get("STATUS")

                        # TODO: stocker les statuts & les envoyer à l'IC

                        timers["status"] = TIMER_CHECK

                        self.analyze_plc_status()

                    elif timer_name == "night_start":
                        scheduler.tasks.scheduling.delay(first_schedule=False, alert=False)
                        timers["night_start"] = 86400
                    elif timer_name == "night_end":

                        # TODO: faire un majordome.system_pause (fin de nuit)

                        observation_manager.tasks.create_calibrations.delay()

                        self.get_night_start_end()

                        scheduler.tasks.scheduling(first_schedule=True, alert=False, night_start=self.night_start, night_end=self.night_end)
                        timers["night_start"] = self.night_start * 3600 * 24 - time.time() - 120

                        timers["night_end"] = self.night_end * 3600 * 24 - time.time()

    def analyze_plc_status(self):
        '''
           Reads the status in DB, and fill missing fields (maybe ?)
           Determines the obs conditions and compare them with the previous ones to know if they changed
           Create a task to stop the system if there is a security problem
        '''

        pass
        # TODO: toute la fct

        # On calcule le nouveau seeing, et si il y a eu du changement, on crée une tâche de majordome.change_obs_conditions