from __future__ import absolute_import

from django.conf import settings
from pyrosapp.models import *

from celery.task import Task

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

from common.Telescope import TelescopeObj
from common.VISCamera import VISCameraObj
from common.NIRCamera import NIRCameraObj

import time

TIMER_CHECK = 10  # in seconds

class monitoring(Task):

    '''
        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.
    '''

    def run(self):

        self.configure_instruments()
        self.connect_to_plc()

        self.update_software_versions()

        self.get_night_start_end()
        self.wait_devices_ready()

        # TODO: décommenter pour lancer un scheduling
        # scheduler.tasks.scheduling(first_schedule=True, alert=False, night_start=self.night_start, night_end=self.night_end)
        alert_manager.tasks.alert_listener.delay()

        time.sleep(5)
        print("monitoring")

        self.timers_loop()

    def configure_instruments(self):

        '''
            Creates the communication objects for each instrument, and give them the basic configurations.
        '''

        self.tel = TelescopeObj()
        self.vis_camera = VISCameraObj()
        self.nir_camera = NIRCameraObj()

        # TODO: ici, on initialise les connections

        self.vis_camera.do("TEMPERATURE", 1.0, -150.0)
        self.nir_camera.do("TEMPERATURE", 1.0, -150.0)
        self.tel.do("HOMING")
        self.tel.do("DOORS", True)

        # Souci : gestion des instruments en global
        # Cette fonction dépendra du moyen de partager les connections des instruments

    def connect_to_plc(self):

        '''
            Initialize the connection to the PLC
        '''

        # TODO: initialiser la co avec le plc et stocker les identifiants de la co dans self
        pass

    def update_software_versions(self):

        '''
            Reads the softwares versions in the settings.py, store them in the DB and send them to the IC.
        '''

        versions = settings.MODULES_VERSIONS

        for module, version in versions.items():
            same_module_versions = Version.objects.filter(module_name=module)
            if same_module_versions.count() == 0:
                Version.objects.create(module_name=module, version=version)
            elif same_module_versions.order_by("-created")[0].version != version:
                Version.objects.create(module_name=module, version=version)

        # TODO: envoyer les versions à l'IC

    def get_night_start_end(self):

        '''
            Computes the beginning and the end of the following (or current) night
        '''

        # TODO: utiliser un logiciel by AK pour stocker en local le début et la fin de la nuit (on est peut-être dedans)
        self.night_start = time.time() + 180 / 86400
        self.night_end = time.time() + 360 / 86400
        pass

    def wait_devices_ready(self):

        '''
            Loop to wait for the device to be idle avec the starting configurations.
        '''

        # TODO: faire une boucle pour attendre que les devices soient prêts
        pass

    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":
                        # TODO: get PLC status
                        status_tel = self.tel.get("STATUS")
                        status_nir = self.nir_camera.get("STATUS")
                        status_vis = self.vis_camera.get("STATUS")
                        # TODO: stocker les statuts & les envoyer à l'IC
                        # TODO: analyser le retour du PLC
                    elif timer_name == "night_start":
                        scheduler.tasks.scheduling.delay(first_schedule=False, alert=False)
                        timers["night_start"] = 86400
                    elif timer_name == "night_end":

                        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)