##from __future__ import unicode_literals

# (EP 21/9/22) To allow autoreferencing (ex: AgentCmd.create() returns a AgentCmd)
from __future__ import annotations

# Stdlib imports

from numpy import False_

from src.device_controller.abstract_component.device_controller import DeviceCmd

from enum import Enum
from datetime import datetime, timedelta, date
from dateutil.relativedelta import relativedelta
import os
import sys

from typing import Any, List, Tuple

from django.core.validators import MaxValueValidator, MinValueValidator

# DJANGO imports

from django.contrib.auth.models import AbstractUser, UserManager

from django.db import models
from django.db.models import Q, Max
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db.models.deletion import DO_NOTHING
from django.db.models.expressions import F

from django.db.models.query import QuerySet

from model_utils import Choices
from django.utils import timezone
# Project imports
# DeviceCommand is used by class Command
sys.path.append("../../..")

''' 
NOT USED - to be removed
class PyrosState(Enum):
    START = 'Starting'
    PA = 'Passive'
    INI = "INIT"
    STAND = "Standby"
    SCHED_START = 'Scheduler startup'
    SCHED = 'Scheduler'
    SCHED_CLOSE = 'Scheduler closing'
'''

"""
STYLE RULES
===========
https://simpleisbetterthancomplex.com/tips/2018/02/10/django-tip-22-designing-better-models.html
https://steelkiwi.com/blog/best-practices-working-django-models-python/

- Model name => singular
    Call it Company instead of Companies. 
    A model definition is the representation of a single object (the object in this example is a company), 
    and not a collection of companies
    The model definition is a class, so always use CapWords convention (no underscores)
    E.g. User, Permission, ContentType, etc.

- For the model’s attributes use snake_case.
    E.g. first_name, last_name, etc

- Blank and Null Fields (https://simpleisbetterthancomplex.com/tips/2016/07/25/django-tip-8-blank-or-null.html)
    - Null: It is database-related. Defines if a given database column will accept null values or not.
    - Blank: It is validation-related. It will be used during forms validation, when calling form.is_valid().
    Do not use null=True for text-based fields that are optional.
    Otherwise, you will end up having two possible values for “no data”, that is: None and an empty string.
    Having two possible values for “no data” is redundant.
    The Django convention is to use the empty string, not NULL.
    Example:
        # The default values of `null` and `blank` are `False`.
        class Person(models.Model):
            name = models.CharField(max_length=255)  # Mandatory
            bio = models.TextField(max_length=500, blank=True)  # Optional (don't put null=True)
            birth_date = models.DateField(null=True, blank=True) # Optional (here you may add null=True)
    The default values of null and blank are False.
    Special case, when you need to accept NULL values for a BooleanField, use NullBooleanField instead.

- Choices : you can use Choices from the model_utils library. Take model Article, for instance:
    from model_utils import Choices
    class Article(models.Model):
        STATUSES = Choices(
            (0, 'draft', _('draft')),
            (1, 'published', _('published'))   )
        status = models.IntegerField(choices=STATUSES, default=STATUSES.draft)

- Reverse Relationships

    - related_name :
    Rule of thumb: if you are not sure what would be the related_name, 
    use the plural of the model holding the ForeignKey.
    ex:
        class Company:
            name = models.CharField(max_length=30)
        class Employee:
            first_name = models.CharField(max_length=30)
            last_name = models.CharField(max_length=30)
            company = models.ForeignKey(Company, on_delete=models.CASCADE, related_name='employees')
    usage:
        google = Company.objects.get(name='Google')
        google.employees.all()
        You can also use the reverse relationship to modify the company field on the Employee instances:
        vitor = Employee.objects.get(first_name='Vitor')
        google = Company.objects.get(name='Google')
        google.employees.add(vitor)

    - related_query_name :
        This kind of relationship also applies to query filters. 
        For example, if I wanted to list all companies that employs people named ‘Vitor’, I could do the following:
        companies = Company.objects.filter(employee__first_name='Vitor')
        If you want to customize the name of this relationship, here is how we do it:
            class Employee:
                first_name = models.CharField(max_length=30)
                last_name = models.CharField(max_length=30)
                company = models.ForeignKey(
                    Company,
                    on_delete=models.CASCADE,
                    related_name='employees',
                    related_query_name='person'
                )
        Then the usage would be:
        companies = Company.objects.filter(person__first_name='Vitor')

    To use it consistently, related_name goes as plural and related_query_name goes as singular.


GENERAL EXAMPLE
=======

from django.db import models
from django.urls import reverse

class Company(models.Model):
    # CHOICES
    PUBLIC_LIMITED_COMPANY = 'PLC'
    PRIVATE_COMPANY_LIMITED = 'LTD'
    LIMITED_LIABILITY_PARTNERSHIP = 'LLP'
    COMPANY_TYPE_CHOICES = (
        (PUBLIC_LIMITED_COMPANY, 'Public limited company'),
        (PRIVATE_COMPANY_LIMITED, 'Private company limited by shares'),
        (LIMITED_LIABILITY_PARTNERSHIP, 'Limited liability partnership'),
    )

    # DATABASE FIELDS
    name = models.CharField('name', max_length=30)
    vat_identification_number = models.CharField('VAT', max_length=20)
    company_type = models.CharField('type', max_length=3, choices=COMPANY_TYPE_CHOICES)

    # MANAGERS
    objects = models.Manager()
    limited_companies = LimitedCompanyManager()

    # META CLASS
    class Meta:
        verbose_name = 'company'
        verbose_name_plural = 'companies'

    # TO STRING METHOD
    def __str__(self):
        return self.name

    # SAVE METHOD
    def save(self, *args, **kwargs):
        do_something()
        super().save(*args, **kwargs)  # Call the "real" save() method.
        do_something_else()

    # ABSOLUTE URL METHOD
    def get_absolute_url(self):
        return reverse('company_details', kwargs={'pk': self.id})

    # OTHER METHODS
    def process_invoices(self):
        do_something()

"""


def printd(*args, **kwargs):

    if os.environ.get('PYROS_DEBUG', '0') == '1':
        print('(MODEL)', *args, **kwargs)

# ---
# --- Utility functions
# ---

def get_or_create_unique_row_from_model(model: models.Model):
    # return model.objects.get(id=1) if model.objects.exists() else model.objects.create(id=1)

    return model.objects.first() if model.objects.exists() else model.objects.create(id=1)


"""
------------------------
   BASE MODEL CLASSES
------------------------
"""

class Device(models.Model):
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    is_online = models.BooleanField(default=False)
    status = models.CharField(max_length=11, blank=True, null=True)
    maintenance_date = models.DateTimeField(blank=True, null=True)

    class Meta:
        abstract = True

    def __str__(self):
        return (str(self.name))

class Request(models.Model):
    pyros_user = models.ForeignKey(
        'PyrosUser', on_delete=models.DO_NOTHING, related_name="requests")
    scientific_program = models.ForeignKey(
        'ScientificProgram', on_delete=models.DO_NOTHING, related_name="requests", blank=True, null=True)
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    is_alert = models.BooleanField(default=False)
    target_type = models.CharField(max_length=8, blank=True, null=True)
    status = models.CharField(max_length=10, blank=True, null=True)
    autodeposit = models.BooleanField(default=False)
    checkpoint = models.CharField(max_length=45, blank=True, null=True)
    flag = models.CharField(max_length=45, blank=True, null=True)
    complete = models.BooleanField(default=False)
    submitted = models.BooleanField(default=False)

    class Meta:
        managed = True
        db_table = 'request'

    def __str__(self):
        return (str(self.name))

"""
------------------------
   OTHER MODEL CLASSES
------------------------
"""

# TODO: A VIRER car remplacé par AgentDeviceStatus

class AgentDeviceTelescopeStatus(models.Model):
    #created = models.DateTimeField('status date', blank=True, null=True, auto_now_add=True)

    updated = models.DateTimeField(
        'status date', blank=True, null=True, auto_now=True)

    radec = models.CharField('agent mode', max_length=30, blank=True)

    class Meta:
        managed = True
        db_table = 'agent_device_telescope_status'
        #verbose_name = "agent survey"
        #verbose_name_plural = "agents survey"

    """
    def __str__(self):
        return (f"Agent {self.name} at {self.updated} in mode {self.mode} and status {self.status}")
    """


class AgentDeviceStatus(models.Model):
    """Table storing various status parameters for EACH Device.

    Attributes:
        attr1 (str): Description of `attr1`.
        attr2 (:obj:`int`, optional): Description of `attr2`.

    """
    #created = models.DateTimeField('status date', blank=True, null=True, auto_now_add=True)

    agent = models.CharField(
        'Name of the agent that saved this parameter', max_length=45, blank=True, null=True)

    #radec = models.CharField('agent mode', max_length=30, blank=True)

    status = models.CharField(
        'status parameters json dictionnary (ex: {radec:..., speed:...})', max_length=300, blank=True, null=True)
    date_updated = models.DateTimeField(
        'status parameter date', blank=True, null=True, auto_now=True)

    class Meta:
        managed = True
        db_table = 'agent_device_status'
        verbose_name = "agent device status"
        verbose_name_plural = "agent devices status"

    def __str__(self):
        return (f"Agent {self.agent} last status is ({self.status}) (saved at {self.date_updated})")

    @classmethod

    def getStatusForAgent(cls, agent: str) -> str:

        return cls.objects.filter(agent=agent)[0] if cls.objects.filter(agent=agent).exists() else cls.objects.create(agent=agent)
        '''
        return cls.objects.filter(agent=agent)[0].status if cls.objects.filter(agent=agent).exists() else cls.objects.create(agent=agent).status
        agent_status = cls.objects.filter(agent=agent)
        if agent_status.exists(): 
            return agent_status[0].status
        else:
            return cls.objects.create(agent=agent)
        '''


class AgentLogs(models.Model):
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    name = models.CharField(max_length=50)
    message = models.TextField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'agent_logs'

    def __str__(self):
        return (f"{self.created} {self.name} {self.message}")


class AgentSurvey(models.Model):
    """
    | id | name | created | updated | validity_duration (default=1mn) | mode (active/idle) | status (launch/init/loop/exit/...) |
    """

    # Statuses
    #STATUSES = Choices('new', 'verified', 'published')
    STATUS_LAUNCH = "LAUNCHED"
    STATUS_INIT = "INITIALIZING"
    STATUS_MAIN_LOOP = "IN_MAIN_LOOP"
    STATUS_PROCESS_LOOP = "IN_PROCESS_LOOP"
    STATUS_EXIT = "EXITING"

    # Modes
    MODE_ACTIVE = "ACTIVE"
    MODE_IDLE = "IDLE"

    MODE_CHOICES = (
        (MODE_ACTIVE, 'Active mode'),
        (MODE_IDLE, 'Idle mode'),
    )

    STATUS_CHOICES = (
        (STATUS_LAUNCH, "LAUNCHED"),
        (STATUS_INIT, "INITIALIZING"),
        (STATUS_MAIN_LOOP, "IN_MAIN_LOOP"),
        (STATUS_PROCESS_LOOP, "IN_PROCESS_LOOP"),
        (STATUS_EXIT, "EXITING"),
    )

    name = models.CharField(max_length=50, unique=True)
    #name = models.CharField(max_length=50, blank=True, null=True, unique=True)
    #created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    validity_duration = models.PositiveIntegerField(default=90)
    #validity_duration = models.DurationField(default=90)

    mode = models.CharField('agent mode', max_length=15,
                            blank=True, choices=MODE_CHOICES)
    status = models.CharField(
        max_length=15, blank=True, choices=STATUS_CHOICES)

    iteration = models.IntegerField(blank=True, null=True)

    nb_restart_max = models.IntegerField(blank=True,null=True,default=3)

    current_nb_restart = models.IntegerField(blank=True,null=True,default=0)

    class Meta:
        managed = True
        db_table = 'agent_survey'
        #verbose_name = "agent survey"
        #verbose_name_plural = "agents survey"

    def __str__(self):
        return (f"Agent {self.name} at {self.updated} in mode {self.mode} and status {self.status}")


class Album(models.Model):
    sequence = models.ForeignKey(
        'Sequence', on_delete=models.CASCADE, related_name="albums")

    # detector = models.ForeignKey(
    #     'Detector', models.DO_NOTHING, related_name="albums", blank=True, null=True)

    #name_of_channel = models.CharField(blank=True,null=True,max_length=150)

    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    complete = models.BooleanField(default=False)

    class Meta:
        managed = True
        db_table = 'album'
        #verbose_name_plural = "Albums"

    def __str__(self):
        return (str(self.name))


class Alert(Request):

    request = models.OneToOneField(
        'Request', on_delete=models.CASCADE, default='', parent_link=True)

    strategyobs = models.ForeignKey(
        'StrategyObs', models.DO_NOTHING, related_name="alerts", blank=True, null=True)
    voevent_file = models.CharField(max_length=45, blank=True, null=True)
    author = models.CharField(max_length=45, blank=True, null=True)

    burst_jd = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    burst_ra = models.FloatField(max_length=45, blank=True, null=True)
    burst_dec = models.FloatField(max_length=45, blank=True, null=True)
    astro_coord_system = models.CharField(max_length=45, blank=True, null=True)

    jd_send = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)
    jd_received = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    trig_id = models.IntegerField(blank=True, null=True)
    error_radius = models.FloatField(max_length=45, blank=True, null=True)
    defly_not_grb = models.BooleanField(default=False)
    editor = models.CharField(max_length=45, blank=True, null=True)
    soln_status = models.CharField(max_length=45, blank=True, null=True)
    pkt_ser_num = models.IntegerField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'alert'

    def __str__(self):
        return str(self.trig_id)

    def request_name(self):
        return self.__str__()

    request_name.short_description = "Name"

class AgentCmd(models.Model):

    """

    Command sent to an Agent

    Can be either :
    - an "agent level" (general or specific) command
    OR
    - a "device level" command

    | id | sender | recipient | name | validity_duration (default=60) | s_deposit_time | r_read_time

    See doc/models_Command_state_diag.pu for PlantUML state diagram

    """

    # -------------- Command CONSTANTS --------------

    # Command status codes

    CMD_STATUS_CODES = Choices(

        # Cmd is pending, waiting for execution
        "CMD_PENDING",  

        ### 1 - ERRORS BEFORE EVEN BEING RUN ###

        # Cmd is invalid (unknown or bad args)
        "CMD_INVALID",

        # Cmd is not yet implemented (by recipient agent)
        "CMD_UNIMPLEMENTED",

        # Cmd was skipped (not run, because the agent is IDLE (or in a mode which does not allow execution of this command)

        "CMD_SKIPPED",

        # Cmd is out of date (expired)
        # because it has been pending for too long

        #"CMD_OUTOFDATE",
        "CMD_EXPIRED",

        ### 2 - RUNNING ###
        # Cmd is running (after having been "read")
        "CMD_RUNNING",  


        ### 3 - ERRORS WHILE RUNNING ###

        # - Cmd was run and finished ok 

        # ( simulé par un sleep(3) dans AgentX.core_process() )
        "CMD_EXECUTED",

        # - Cmd was running, but then an error occured
        "CMD_EXEC_ERROR",  

        # - Cmd was running, but took too much time and timeout was reached
        "CMD_EXEC_TIMEOUT",  

        # - Cmd was aborted, killed by another agent
        #"CMD_KILLED",
        "CMD_EXEC_KILLED",

    )

    # Command default validity duration (from sending time) BEFORE execution, before being perempted (in sec)
    # => Each command validity can be set by SENDER when sending command, it will then be managed by RECIPIENT
    # => From the time a command was sent (cmd.s_deposit_time), it is still valid during DEFAULT_VALIDITY_DURATION sec.

    # => After that, it is considered as "expired" (obsolete) and must be marked as "CMD_OUTOFDATE" and not be executed anymore (and can be purged)
    # => Thus, a command is expired FROM time = s_deposit_time + VALIDITY_DURATION
    # (except if it is RUNNING, i.e. in state CMD_RUNNING)
    DEFAULT_VALIDITY_DURATION = 1 * 3600 # s

    # Command default execution timeout (in sec)

    # => Each command timeout is set by RECIPIENT (in AGENT_SPECIFIC_COMMANDS), and it will be managed by RECIPIENT

    # => Execution of a command MUST NOT last more than EXEC_TIMEOUT seconds (from execution start time cmd.r_start_time)
    # => Otherwise the (recipient) agent executing the command is responsible to abort it and mark it as "CMD_KILLED"
    DEFAULT_EXEC_TIMEOUT = 60 # s

    # -------------- Command FIELDS --------------

    #sender = models.CharField(max_length=50, blank=True, null=True, unique=True)
    # Sender and Recipient agents
    sender = models.CharField(max_length=50, help_text='sender agent name', null=False)
    recipient = models.CharField(max_length=50, help_text='recipient agent name', null=False)
    ##name = models.CharField(max_length=400, help_text='command name', null=False)
    full_name = models.CharField(max_length=400, help_text='command full name (with type and args)', null=False)
    

    validity_duration = models.PositiveIntegerField('(in sec)', default=DEFAULT_VALIDITY_DURATION)

    exec_timeout = models.PositiveIntegerField('(in sec)', default=DEFAULT_EXEC_TIMEOUT)
    
    #state = models.CharField(choices = CMD_STATUS_CODES, default=CMD_STATUS_CODES.CMD_PENDING, max_length=20)
    state = models.CharField(choices=CMD_STATUS_CODES, default=CMD_STATUS_CODES.CMD_PENDING, max_length=20)
    #state = models.IntegerField(choices=CMD_STATUS_CODES, default=RSCODE_PENDING)

    # TODO: maybe à mettre au format json (key:value)
    result = models.CharField(max_length=400, blank=True)

    # - on creation: (AUTO) Automatically set at table line creation (line created by the sender)
    s_deposit_time = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    # - on reading:
    r_read_time = models.DateTimeField(null=True)
    # - on launching:
    r_start_time = models.DateTimeField(null=True)

    # - on end (after execution started or not)
    #end_time = models.DateTimeField(null=True)
    r_end_time = models.DateTimeField(null=True)

    # Other agent (than sender or recipient) that set this command to KILLED or EXPIRED
    killer_agent_name = models.CharField(max_length=50, help_text='sender agent name', null=True)

    # Intern field, not saved in DB
    _device_command = None

    class Meta:
        managed = True
        db_table = 'command'
        #verbose_name = "agent survey"
        #verbose_name_plural = "agents survey"

    _AGENT_GENERAL_COMMANDS = [

        # DO commands

        # -----------
        

        # - Evaluate the expression given (ex: do_eval 4+3)

        "do_eval",

        # GET commands

        # ------------

        # - Get agent current STATE
        "get_current_state",

        # - Get agent current STATE (IN_MAIN_LOOP, ...)

        #@deprecated

        "get_state",

        
        # - Get agent current MODE (idle, routine, attentive)

        #@deprecated

        "get_mode",
        

        # SET commands

        # -----------

        # - Set agent current STATE (IN_MAIN_LOOP, ...) => forbidden
        #"set_state",

        
        # - Set agent current MODE (idle, routine, attentive)

        "set_current_mode", # + value to set
        #@deprecated

        "set_mode", # + value to set

        
        # -----------

        # ### (PRIORITY) DO Commands => executed in priority (even if other pending commands exist) ###
        # -----------
        

        # - Finish your current command and then make a normal clean stop
        # ARGS (optional) :
        #   - "asap" (default) (wait for agent to finish its current processing, then exit)
        #   - "now" (abort agent current processing + exit)
        #   - "noprio" (not priority) (priority by default)
        "do_stop",
        # TODO: a virer => do_stop asap

        # @deprecated

        "do_exit",
        # TODO: a virer => do_stop now

        # @deprecated

        "do_abort",

        # - 
        # ARGS :
        #   - "stop" : Temporaly stop execution of new commands (let them accumulate)
        #   - "resume" : Resume execution of commands (accumulated since "do_exec_commands stop")
        #   - "noprio" : not priority (by default => priority)        
        "do_exec_commands",

        # - Stop currently running command or/and routine

        # ARGS :
        #   - "cmd" : stop currently running specific command
        #   - "routine" : stop currently running routine process

        #   - "both" : stop currently running current cmd and routine process

        "do_stop_current", # + arg "cmd" or "routine"

        # TODO: a virer => do_stop_current now
        "do_abort_current_command",

        # - Remove all your pending commands
        "do_flush_commands", 

        # - Restart your global loop (starting with init())
        # ARGS (optional) :
        #   - "asap" (default) (wait for agent to finish its current processing, then restart loop)
        #   - "now" (abort agent current processing + restart loop)

        #   - "noprio" (not priority, priority by default)

        "do_restart_loop", # + arg "asap" (default) or "now"

        "get_specific_cmds",

    ]

    # Priority commands, executed as soon as in the received commands list (BEFORE any other pending command)
    # NB : must be a subset of _AGENT_GENERAL_COMMANDS
    _AGENT_GENERAL_PRIORITY_COMMANDS = [
        #"do_exit",
        "do_flush_commands", 

        "do_exec_commands"

        "do_restart_loop",

        "do_stop_current",
        "do_stop",

    ]

    # -------------- Command CLASS (static) METHODS --------------

    # Avoid to override the Model __init__ method

    # See https://docs.djangoproject.com/en/stable/ref/models/instances/#creating-objects

    @classmethod

    def create(cls, agent_from:str, agent_to:str, cmd_name:str, cmd_args:str=None, cmd_validity:int=None) -> AgentCmd :

        #print(agent_to)
        if '.' in agent_to:
            agent_to, component_name = agent_to.split('.')

            cmd_name = component_name+'.'+cmd_name

        if cmd_args:

            cmd_name += ' ' + cmd_args

        # cls._device_command=DeviceCommand(cmd_name)

        if cmd_validity is None: cmd_validity = cls.DEFAULT_VALIDITY_DURATION

        #if cmd_timeout is None: cmd_timeout = cls.DEFAULT_EXEC_TIMEOUT

        return cls(

            sender=agent_from,
            recipient=agent_to,

            full_name=cmd_name,

            validity_duration=cmd_validity,

            #exec_timeout=cmd_timeout,

        )

    """
    @classmethod
    def send(cls, cmd:Command):
        cls.objects.create(sender=cmd.name, recipient=cmd.recipient, name=cmd.name)
    """

    @classmethod

    def send_cmd_from_to(cls, agent_from, agent_to, cmd_name, cmd_args=None, cmd_validity:int=None)->AgentCmd:
        """ Create and send a command, then return it """

        # def send(cls, from_agent, to_agent, cmd_name, cmd_args=None):

        """
        ex: send("AgentA",“AgentB”,"EVAL”,“3+4”)
        """
        '''
        if cmd_args: cmd_name += ' '+cmd_args
        #Command.objects.create(sender=self.name, recipient=r_agent, name=cmd_name)
        cmd = cls(sender=from_agent, recipient=to_agent, name=cmd_name)
        '''

        cmd = cls.create(agent_from, agent_to, cmd_name, cmd_args, cmd_validity)

        cmd.send()

        # cmd.set_as_pending()
        # cmd.save()

        return cmd

    @classmethod

    def max_deposit_date_for_peremption(cls):

        return datetime.utcnow().astimezone() - timedelta(seconds=cls.DEFAULT_VALIDITY_DURATION)
        #return datetime.utcnow().astimezone() - timedelta(hours=cls.DEFAULT_VALIDITY_DURATION)

    @classmethod
    def delete_commands_with_running_status_for_agent(cls, agent_name):
        printd("Delete (false) 'running' commands if exists:")
        running_commands = cls.objects.filter(
            # only commands for agent agent_name

            recipient=agent_name,

            # only running commands

            state=cls.CMD_STATUS_CODES.CMD_RUNNING,

            # only not expired commands

            #s_deposit_time__gte = cls.max_deposit_date_for_peremption(),

        )
        if running_commands:
            AgentCmd.show_commands(running_commands)
            running_commands.delete()

        else:
            printd("<None>")

    @classmethod
    def delete_pending_commands_for_agent(cls, agent_name):
        """
        Delete all pending commands sent to agent_name,
        except very recent commands.
        This (exception) is to avoid a "data race" where for example agentB is executing a "flush" command 
        while agentA is sending command to agentB... :
        - agentB will then delete the command just sent by agentA
        - agentA will check regularly the status of its sent command, and this will crash as this command exists no more !!
        """
        printd("Delete all pending command(s) if exists (except very recent ones):")

        now_minus_2sec = datetime.utcnow().astimezone() - timedelta(seconds=2)

        #print("now_minus_2sec", now_minus_2sec)
        pending_commands = cls.objects.filter(
            # only commands for agent agent_name

            recipient=agent_name,

            # only running commands

            state=cls.CMD_STATUS_CODES.CMD_PENDING,

            # except very recent commands : take only commands that are more than 2 sec old

            s_deposit_time__lt=now_minus_2sec

        )
        if pending_commands:
            AgentCmd.show_commands(pending_commands)
            pending_commands.delete()

        else:
            printd("<None>")

    @classmethod
    def get_pending_and_running_commands_for_agent(cls, agent_name):
        #print("peremption date", COMMAND_PEREMPTION_DATE_FROM_NOW)
        return cls.objects.filter(

            # only pending or running commands
            Q(state=cls.CMD_STATUS_CODES.CMD_PENDING) | Q(state=cls.CMD_STATUS_CODES.CMD_RUNNING),

            # only commands for agent agent_name

            recipient=agent_name,
            # recipient__startswith=agent_name,
            # Q(recipient.split('.')[0] = agent_name),

            # only not expired commands

            #s_deposit_time__gte = cls.max_deposit_date_for_peremption(),

        ).order_by("s_deposit_time")

    @classmethod
    def get_commands_sent_to_agent(cls, agent_name):
        return cls.objects.filter(recipient=agent_name)

    @classmethod
    def get_commands_sent_by_agent(cls, agent_name):
        return cls.objects.filter(sender=agent_name)

    @classmethod
    def get_last_N_commands_sent_to_agent(cls, agent_name, N):

        # filter(since=since)
        # return cls.objects.all()[:nb_cmds]

        #commands = cls.objects.filter(recipient = agent_name).order_by('-id')[:N]

        commands = cls.get_commands_sent_to_agent(
            agent_name).order_by('-id')[:N]

        return list(reversed(commands))

    @classmethod
    def get_last_N_commands_sent_by_agent(cls, agent_name, N):

        # filter(since=since)
        # return cls.objects.all()[:nb_cmds]

        #commands = cls.objects.filter(recipient = agent_name).order_by('-id')[:N]

        commands = cls.get_commands_sent_by_agent(
            agent_name).order_by('-id')[:N]

        return list(reversed(commands))

    @classmethod
    def purge_old_commands_sent_to_agent(cls, agent_name):
        """

        Delete commands (which agent_name is recipient of) older than VALIDITY_DURATION (like 1h)

        ATTENTION !!! EXCEPT the RUNNING command !!!
        NB: datetime.utcnow() is equivalent to datetime.now(timezone.utc)
        """

        printd(

            f"(Looking for commands sent to me that are not executing and perempted - i.e. older than {cls.DEFAULT_VALIDITY_DURATION/60} minute(s))")

        #COMMAND_PEREMPTION_DATE_FROM_NOW = datetime.utcnow() - timedelta(hours = cls.COMMANDS_PEREMPTION_HOURS)
        #print("peremption date", COMMAND_PEREMPTION_DATE_FROM_NOW)
        old_commands = cls.objects.filter(
            # only commands for agent agent_name

            recipient=agent_name,

            # only expired commands

            s_deposit_time__lt=cls.max_deposit_date_for_peremption(),

        ).exclude(

            state=cls.CMD_STATUS_CODES.CMD_RUNNING

        )
        if old_commands.exists():
            printd("Found old commands to delete:")
            #for cmd in old_commands: print(cmd)
            cls.show_commands(old_commands)
            old_commands.delete()
        else:
            printd("<None>")

    @classmethod

    # def show_commands(cls, commands:models.query):
    def show_commands(cls, commands: list, do_it: bool = False):
        # def show_commands(cls, commands:List[Commmand]):

        #if not commands.exists(): print("<No command>")
        commands = list(commands)

        if len(commands) == 0:

            print("<None>")
            #if do_it: print("<None>")
            #else: printd("<None>")

        for cmd in commands:

            print("-", cmd.name, cmd)
            #if do_it: print("-", cmd.name, cmd)
            #else: printd("-", cmd.name, cmd)

    # -------------- AgentCmd INSTANCE METHODS --------------

    def __str__(self):

        # return (f"Commmand '{self.name}' ({self.state}) sent by agent {self.sender} to agent {self.recipient} at {self.s_deposit_time}")

        cmd_sent_time = f" at {self.s_deposit_time}" if self.s_deposit_time else ''

        return (f"Commmand '{self.full_name}' ({self.state}) sent to agent {self.recipient}{cmd_sent_time} (validity={self.validity_duration}s,timeout={self.exec_timeout}s) [by agent {self.sender}]")

    @property

    def device_command(self) -> DeviceCmd :

        if not self._device_command:
            self._device_command = DeviceCmd(self.full_name)
            #dc = self._device_command
            #print("...DEVICE CMD:", dc.full_name, dc.name, dc.devtype, dc.args)
        return self._device_command

    @property

    #def name_and_args(self) -> Tuple[str, str] :
    def name_and_args(self) -> Tuple[str, List] :
        ###return self.device_command.name_and_args

        '''
        cmd_name_and_args = self.full_name
        if '.' in cmd_name_and_args:
            cmd_name_and_args = cmd_name_and_args.split('.')[1]
        return cmd_name_and_args
        '''

        ''' Return command name and args if exist '''
        # By default, no args

        #cmd_args = None
        cmd_args = []

        cmd_name = self.full_name

        if ' ' in cmd_name:
            cmd_name, *cmd_args = cmd_name.split(' ')

        return cmd_name, cmd_args

    #def get_full_name_parts(self) -> list :
    def get_full_name_parts(self) -> Tuple[str, str, str] :

        ''' Return command device type, name, and args from any command type (agent or device level) '''

        # No device type by default for an Agent command
        # cmd_type ?
        dev_type = None
        
        # By default, no args
        cmd_args = None

        cmd_name = self.full_name
        
        # Device command with device component type (dev_type)
        if '.' in cmd_name: 
            return self.device_command.get_full_name_parts()

        # Simple command with args (no dev_type)
        if ' ' in cmd_name:

            cmd_name, *cmd_args = self.name_and_args

        return dev_type, cmd_name, cmd_args

    @property
    def name(self):

        ###return self.device_command.name
        #_,cmd_name,_ = self.get_full_name_parts()
        cmd_name,_ = self.name_and_args

        return cmd_name

    @property
    def args(self):

        ###return self.device_command.args
        #_,_,cmd_args = self.get_full_name_parts()
        _,cmd_args = self.name_and_args

        return cmd_args

    @property
    def device_type(self): return self.device_command.devtype

    def send(self):

        # self.save()

        self.set_as_pending()

    '''
    def tokenize(self):
        cmd_name, *cmd_args = self.full_name.split(' ')
        return cmd_name, cmd_args
    '''

    # --- BOOLEAN (test) functions ---

    def is_agent_general_cmd(self):
        """
        Is this a general command ?
        It is the case if command is of style "do_set:state:idle" or "do_restart" or "do_flush"...
        """
        ##name = self.name
        ##if " " in name: name,args = name.split()
        ##name = self.name.split(' ')[0]
        ##cmd_name, _ = self.tokenize()

        # return cmd_name in self.GENERIC_COMMANDS

        #print("**********************CMD NAME is", self.name, "in ???", self._AGENT_GENERAL_COMMANDS)
        return self.name in self._AGENT_GENERAL_COMMANDS

        # "CMD_OUTOFDATE" # cde périmée

    def is_agent_general_priority_cmd(self):
        return self.name in self._AGENT_GENERAL_PRIORITY_COMMANDS

    def is_read(self):
        return self.r_read_time is not None

    def is_pending(self):
        return self.state == self.CMD_STATUS_CODES.CMD_PENDING

    def is_running(self):

        return self.state == self.CMD_STATUS_CODES.CMD_RUNNING

    def is_executed(self):
        return self.state == self.CMD_STATUS_CODES.CMD_EXECUTED

    def is_skipped(self):
        return self.state == self.CMD_STATUS_CODES.CMD_SKIPPED

    def is_killed(self):

        return self.state == self.CMD_STATUS_CODES.CMD_EXEC_KILLED

    def is_expired(self):

        if self.state == self.CMD_STATUS_CODES.CMD_EXPIRED: return True
        # Must NOT be running
        if self.is_running(): return False

        # return (datetime.utcnow() - self.s_deposit_time) > timedelta(seconds = self.validity_duration)

        elapsed_time = (datetime.utcnow().astimezone() - self.s_deposit_time)
        printd("elapsed_time", elapsed_time)

        return elapsed_time > timedelta(seconds=self.validity_duration)

        """
        elapsed_time = cmd.r_read_time - cmd.s_deposit_time
        max_time = timedelta(seconds = cmd.validity_duration)
        print(f"Elapsed time is {elapsed_time}, (max is {max_time})")
        if elapsed_time > max_time:
        """

    def is_timeout(self):

        if self.state == self.CMD_STATUS_CODES.CMD_EXEC_TIMEOUT: return True

        # Must be running
        if not self.is_running(): return False
        # return (datetime.utcnow() - self.s_deposit_time) > timedelta(seconds = self.validity_duration)
        elapsed_time = (datetime.utcnow().astimezone() - self.r_start_time)
        printd("elapsed_time since exec", elapsed_time)
        return elapsed_time > timedelta(seconds=self.exec_timeout)

    # --- GETTERS/SETTERS functions ---

    def get_result(self):
        return self.result

    def get_updated_result(self):
        self.refresh_from_db()
        return self.result

    def set_result(self, result: str, do_save:bool=True):

        self.result = result

        if do_save: self.save()

    def set_read_time(self, do_save:bool=True):

        self.r_read_time = datetime.utcnow().astimezone()
        # Optimization: update only 1 field

        if do_save: self.save(update_fields=["r_read_time"])

    #
    # Set cmd status
    #

    def set_as_pending(self):
        self.set_state_to(self.CMD_STATUS_CODES.CMD_PENDING)

    # from PENDING
    def set_as_unimplemented(self, result:str=None):
        assert self.is_pending()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_UNIMPLEMENTED)

    # from PENDING
    def set_as_invalid(self, result:str=None):
        assert self.is_pending()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_INVALID)

    # from PENDING
    def set_as_skipped(self, result:str=None):
        assert self.is_pending()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_SKIPPED, result=result)

    # from PENDING
    def set_as_expired(self):
        assert self.is_pending()
        print(f"- Set this command as expired (older than its validity duration of {self.validity_duration}s): {self}")
        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXPIRED)
    
    # from PENDING
    def set_as_running(self):
        assert self.is_pending()
        printd(f"- Set command {self.name} as running")
        self.set_state_to(self.CMD_STATUS_CODES.CMD_RUNNING)

    '''
    def set_as_executed(self):
        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXECUTED)
    '''
    # from RUNNING

    def set_as_processed(self, result:str=None):

        assert self.is_running()

        printd(f"- Set command {self.name} as processed")

        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXECUTED, result=result)

        # print(self)

        """
        self.state = self.CMD_STATUS_CODES.CMD_EXECUTED
        self.r_processed_time = datetime.utcnow().astimezone()
        self.save()
        """
        # Optimization: update the related fields, but does not work, why ?
        ##self.save(update_fields=["state", "r_processed_time"])

    #def set_as_outofdate(self):

    # from RUNNING
    def set_as_exec_error(self, result:str=None):
        assert self.is_running()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXEC_ERROR, result=result)

    # from RUNNING
    def set_as_exec_timeout(self, result:str=None):
        assert self.is_running()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXEC_TIMEOUT, result=result)

    # from RUNNING
    def set_as_exec_timeout(self, result:str=None):
        assert self.is_running()
        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXEC_TIMEOUT, result=result)

    # from RUNNING

    def set_as_killed_by(self, author_agent: str):

        assert self.is_running()

        printd(f"- Set command {self.name} as killed")
        #print(f"- Set this command as killed: {self}")

        self.set_state_to(self.CMD_STATUS_CODES.CMD_EXEC_KILLED, author_agent)

    def set_state_to(self, status: str, author_agent_name: str = None, result:str=None):
        '''
        If comment is present it will be set in the "result" field
        '''

        now_time = datetime.utcnow().astimezone()

        if result: 
            self.set_result(result, False)

        if status in (self.CMD_STATUS_CODES.CMD_RUNNING, self.CMD_STATUS_CODES.CMD_SKIPPED, self.CMD_STATUS_CODES.CMD_EXPIRED):

            assert self.is_pending()
            if status == self.CMD_STATUS_CODES.CMD_RUNNING:
                self.r_start_time = now_time
            elif status in (self.CMD_STATUS_CODES.CMD_SKIPPED):

                self.r_end_time = now_time

            # EXPIRED

            elif status == self.CMD_STATUS_CODES.CMD_EXPIRED:
                self.r_end_time = now_time

                self.killer_agent_name = author_agent_name

        elif status in (self.CMD_STATUS_CODES.CMD_EXECUTED, self.CMD_STATUS_CODES.CMD_EXEC_KILLED):

            assert self.is_running()

            self.r_end_time = now_time
            if status == self.CMD_STATUS_CODES.CMD_EXEC_KILLED:

                self.killer_agent_name = author_agent_name
        # Update command status
        self.state = status
        self.save()
        # Optimization, but does not work, why ?...

        # self.save(update_fields=["state"])

class Config(models.Model):

    PYROS_STATE = ["Starting", "Passive", "Standby",
                   "Remote", "Startup", "Scheduler", "Closing"]

    id = models.IntegerField(default='1', primary_key=True)
    #latitude = models.FloatField(default=1)
    latitude = models.DecimalField(

        max_digits=4, decimal_places=2,

        default=1,
        validators=[
            MaxValueValidator(90),
            MinValueValidator(-90)
        ]
    )
    local_time_zone = models.FloatField(default=1)
    #longitude = models.FloatField(default=1)
    longitude = models.DecimalField(

        max_digits=5, decimal_places=2,

        default=1,
        validators=[
            MaxValueValidator(360),
            MinValueValidator(-360)
        ]
    )
    altitude = models.FloatField(default=1)
    horizon_line = models.FloatField(default=1)
    row_data_save_frequency = models.IntegerField(default='300')
    request_frequency = models.IntegerField(default='300')
    analysed_data_save = models.IntegerField(default='300')
    telescope_ip_address = models.CharField(max_length=45, default="127.0.0.1")
    camera_ip_address = models.CharField(max_length=45, default="127.0.0.1")
    plc_ip_address = models.CharField(max_length=45, default="127.0.0.1")

    # TODO: changer ça, c'est pas clair du tout...
    # True = mode Scheduler-standby, False = mode Remote !!!!
    global_mode = models.BooleanField(default='True')

    ack = models.BooleanField(default='False')
    bypass = models.BooleanField(default='True')
    lock = models.BooleanField(default='False')
    pyros_state = models.CharField(max_length=25, default=PYROS_STATE[0])
    force_passive_mode = models.BooleanField(default='False')
    plc_timeout_seconds = models.PositiveIntegerField(default=60)
    majordome_state = models.CharField(max_length=25, default="")
    ntc = models.BooleanField(default='False')
    majordome_restarted = models.BooleanField(default='False')

    class Meta:
        managed = True
        db_table = 'config'
        verbose_name_plural = "Config"

    def __str__(self):
        return (str(self.__dict__))

class Country(models.Model):
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    quota = models.FloatField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'country'
        verbose_name_plural = "Countries"

    def __str__(self):
        return (str(self.name))


class Detector(Device):
    VIS = "Visible camera"
    NIR = "Cagire"

    telescope = models.ForeignKey(
        'Telescope', models.DO_NOTHING, related_name="detectors")
    nb_photo_x = models.IntegerField(blank=True, null=True)
    nb_photo_y = models.IntegerField(blank=True, null=True)
    photo_size_x = models.IntegerField(blank=True, null=True)
    photo_size_y = models.IntegerField(blank=True, null=True)
    has_shutter = models.BooleanField(default=False)
    equivalent_foc_len = models.CharField(max_length=45, blank=True, null=True)
    acq_start = models.DateTimeField(blank=True, null=True)
    acq_stop = models.DateTimeField(blank=True, null=True)
    check_temp = models.FloatField(blank=True, null=True)
    gain = models.FloatField(blank=True, null=True)
    readout_noise = models.FloatField(blank=True, null=True)
    readout_time = models.FloatField(blank=True, null=True)
    idcam_readout_mode = models.IntegerField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'detector'

    def __str__(self):
        return str(self.name)

    def device_name(self):
        return self.__str__()
    device_name.short_description = "Name"


class Dome(Device):
    DOME = "Dome"

    open = models.BooleanField(default=False, blank=True)

    class Meta:
        managed = True
        db_table = 'dome'

    def __str__(self):
        return str(self.name)

    def device_name(self):
        return self.__str__()
    device_name.short_description = "Name"

class Filter(Device):
    VIS_FILTER_1 = "First visible filter"
    VIS_FILTER_2 = "Second visible filter"
    NIR_FILTER_1 = "First infrared filter"
    NIR_FILTER_2 = "Second infrared filter"

    filter_wheel = models.ForeignKey(
        "FilterWheel", models.DO_NOTHING, related_name="filters", blank=True, null=True)
    category = models.CharField(max_length=1, blank=True, null=True)
    transmission_curve_doc = models.CharField(
        max_length=45, blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'filter'

    def __str__(self):
        return (str(self.name))

    def device_name(self):
        return self.__str__()
    device_name.short_description = "Name"


class FilterWheel(Device):
    detector = models.OneToOneField(Detector, on_delete=models.CASCADE,
                                    related_name="filter_wheel", blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'filter_wheel'

    def __str__(self):
        return (str(self.name))

    def device_name(self):
        return self.__str__()
    device_name.short_description = "Name"


class Image(models.Model):

    plan = models.ForeignKey(
        'Plan', on_delete=models.CASCADE, related_name="images")

    nrtanalysis = models.ForeignKey(
        'NrtAnalysis', models.DO_NOTHING, blank=True, null=True, related_name="images")
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    date_from_gps = models.CharField(max_length=45, blank=True, null=True)
    level = models.IntegerField(blank=True, null=True)
    type = models.CharField(max_length=5, blank=True, null=True)
    quality = models.CharField(max_length=45, blank=True, null=True)
    flaggps = models.CharField(max_length=45, blank=True, null=True)
    exposure = models.CharField(max_length=45, blank=True, null=True)
    tempext = models.CharField(max_length=45, blank=True, null=True)
    pressure = models.CharField(max_length=45, blank=True, null=True)
    humidext = models.CharField(max_length=45, blank=True, null=True)
    wind = models.CharField(max_length=45, blank=True, null=True)
    wind_dir = models.CharField(max_length=45, blank=True, null=True)
    dwnimg = models.CharField(max_length=45, blank=True, null=True)
    dwncata = models.CharField(max_length=45, blank=True, null=True)
    dwn = models.CharField(max_length=45, blank=True, null=True)
    level0_fits_name = models.CharField(max_length=45, blank=True, null=True)
    level1a_fits_name = models.CharField(max_length=45, blank=True, null=True)
    level1b_fits_name = models.CharField(max_length=45, blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'image'

    def __str__(self):
        return (str(self.name))


class Log(models.Model):
    agent = models.CharField(max_length=45, blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    message = models.TextField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'log'

    def __str__(self):
        return (str(self.agent))


class NrtAnalysis(models.Model):
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    analysis = models.TextField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'nrtanalysis'
        verbose_name_plural = "Nrt analyzes"

    def __str__(self):
        return (str(self.name))

"""

class Plan(models.Model):
    album = models.ForeignKey(Album, on_delete=models.CASCADE, related_name="plans")
    filter = models.ForeignKey(Filter, models.DO_NOTHING, related_name="plans", blank=True, null=True)
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.CharField(max_length=45, blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    duration = models.FloatField(default=0, blank=True, null=True)
    position = models.CharField(max_length=45, blank=True, null=True)
    exposure_time = models.FloatField(blank=True, null=True)
    nb_images = models.IntegerField(blank=True, null=True)
    dithering = models.BooleanField(default=False)
    complete = models.BooleanField(default=False)

    class Meta:
        managed = True
        db_table = 'plan'

    def __str__(self):
        return (str(self.name))

"""

class Plan(models.Model):

    album = models.ForeignKey(
        Album, on_delete=models.CASCADE, related_name="plans")

    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    duration = models.FloatField(default=0, blank=True, null=True)

    nb_images = models.PositiveIntegerField(
        blank=True, null=True, validators=[MinValueValidator(1)])
    config_attributes = models.JSONField(blank=True, null=True)

    complete = models.BooleanField(default=False)

    class Meta:
        db_table = "plan"

    def __str__(self) -> str:
        return f"Plan of Album {self.album.name} has {self.nb_images} image(s)"

class PlcDeviceStatus(models.Model):

    device = models.ForeignKey(
        'PlcDevice', on_delete=models.CASCADE, related_name='current_status')
    created = models.DateTimeField(
        auto_now_add=True, editable=False, blank=True)
    outside_temp = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    outside_temp_unit = models.CharField(max_length=45, blank=True, null=True)

    outside_humidity = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)
    outside_humidity_unit = models.CharField(
        max_length=45, blank=True, null=True)
    pressure = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    pressure_unit = models.CharField(max_length=45, blank=True, null=True)

    rain_rate = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    rain_rate_unit = models.CharField(max_length=45, blank=True, null=True)

    wind_speed = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    wind_speed_unit = models.CharField(max_length=45, blank=True, null=True)

    wind_dir = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    wind_dir_unit = models.CharField(max_length=45, blank=True, null=True)

    dew_point = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    dew_point_unit = models.CharField(max_length=45, blank=True, null=True)

    analog = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    analog_unit = models.CharField(max_length=45, blank=True, null=True)

    digital = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    digital_unit = models.CharField(max_length=45, blank=True, null=True)

    inside_temp = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    inside_temp_unit = models.CharField(max_length=45, blank=True, null=True)

    inside_humidity = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)
    inside_humidity_unit = models.CharField(
        max_length=45, blank=True, null=True)

    wind_dir_cardinal = models.CharField(max_length=45, blank=True, null=True)

    wind_dir_cardinal_unit = models.CharField(
        max_length=45, blank=True, null=True)
    sensor_temperature = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)
    sensor_temperature_unit = models.CharField(
        max_length=45, blank=True, null=True)
    sky_temperature = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)
    sky_temperature_unit = models.CharField(
        max_length=45,  blank=True, null=True)

    status = models.CharField(max_length=45, blank=True, null=True)

    current = models.DecimalField(
        max_digits=15, decimal_places=8, blank=True, null=True)

    current_unit = models.CharField(max_length=45, blank=True, null=True)
    is_safe = models.BooleanField(default=True)
    plc_mode = models.CharField(max_length=4, null=True)
    lights = models.CharField(max_length=3, null=True)
    shutters = models.CharField(max_length=5, null=True)

    class Meta:
        managed = True
        db_table = 'plc_devices_status'

    def __str__(self):
        return (str(self.__dict__))

    '''
        TODO : This function is Ugly,
        we should change this with a function pointer array
        and setters getters for each attribute
    '''

    def setValue(self, key, value, unit=""):
        if key == "Temperature_outside":
            self.outside_temp = value
            self.outside_temp_unit = unit
        elif key == "Humidity_outside":
            self.outside_humidity = value
            self.outside_humidity_unit = unit
        elif key == "_Pressure":
            self.pressure = value
            self.pressure_unit = unit

        elif key == "Rain_boolean":  # RainRate

            self.rain_rate = value
            self.rain_rate_unit = 'boulean'
        elif key == "Wind_speed":
            self.wind_speed = value
            self.wind_speed_unit = unit
        elif key == "Wind_dir":
            self.wind_dir = value
            self.wind_dir_unit = unit
        elif key == "_DewPoint":
            self.dew_point = value
            self.dew_point_unit = unit
        elif key == "_analog":
            self.analog = value
            self.analog_unit = unit
        elif key == "_digital":
            self.digital = value
            self.digital_unit = unit
        elif key == "_InsideTemp":
            self.inside_temp = value
            self.inside_temp_unit = unit
        elif key == "_InsideHumidity":
            self.inside_humidity = value
            self.inside_humidity_unit = unit
        elif key == "_WindDirCardinal":
            self.wind_dir_cardinal = value
            self.wind_dir_cardinal_unit = unit
        elif key == "_SensorTemperature":
            self.sensor_temperature = value
            self.sensor_temperature_unit = unit
        elif key == "_SkyTemperature":
            self.sky_temperature = value
            self.sky_temperature_unit = unit
        # PM 20190222 try patch
        elif key == "Error_code":
            self.status = value
        elif key == "current":
            self.current = value
            self.current_unit = unit
        elif key == "mode":
            self.plc_mode = value
        elif key == "is_safe":
            self.is_safe = value
        elif key == "LIGHTS":
            self.lights = value
        elif key == "SHUTTERS":
            self.shutters = value
        else:
            # PM 20190222 ignore unrecognized
            #raise KeyError("Key " + str(key) + " unrecognized")
            pass

class PlcDevice(Device):
    #device = models.ForeignKey('Plc', on_delete=models.CASCADE, related_name='plc_devices')
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)

    class Meta:
        managed = True
        db_table = 'plc_devices'

    def __str__(self):
        return str(self.name)

# class Plc(Device):

 #   last_update_status = models.DateTimeField(blank=True, null=True)
#    i
 #   class Meta:
  #      managed = True
   #     db_table = 'plc'

class ScienceTheme(models.Model):

    name = models.CharField(max_length=120, blank=False,
                            null=False, default="", unique=True)

    def __str__(self) -> str:
        return str(self.name)

    class Meta:
        db_table = "science_theme"

class Institute(models.Model):

    name = models.CharField(max_length=100, blank=False,
                            null=False, unique=True)
    quota = models.IntegerField(
        validators=[MinValueValidator(0), MaxValueValidator(100)])

    #representative_user = models.ForeignKey("PyrosUser", on_delete=models.DO_NOTHING,related_name="institutes",default=1)

    def __str__(self) -> str:
        return str(self.name)

    class Meta:
        db_table = "institute"

class PyrosUserManager(UserManager):
    def tac_users(self):
        return PyrosUser.objects.filter(user_level__name="TAC")

    def unit_users(self):

        return PyrosUser.objects.filter(Q(user_level__name="Unit-PI") | Q(user_level__name="Unit-board"))

class PyrosUser(AbstractUser):

    username = models.CharField(
        max_length=255, blank=False, null=False, unique=True)

    is_active = models.BooleanField(default='False')
    first_time = models.BooleanField(default='False')
    country = models.ForeignKey(
        Country, on_delete=models.DO_NOTHING, related_name="pyros_users")
    user_level = models.ManyToManyField(
        'UserLevel', related_name="pyros_users")
    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    tel = models.CharField(max_length=45, blank=True, null=True)
    address = models.TextField(max_length=100, blank=True, null=True)
    laboratory = models.CharField(max_length=45, blank=True, null=True)

    institute = models.ForeignKey(
        Institute, on_delete=DO_NOTHING, related_name="pyros_users")

    is_institute_representative = models.BooleanField(default=False)

    motive_of_registration = models.TextField(
        max_length=300, blank=False, default="")

    # last_connect = models.DateTimeField(blank=True, null=True)
    # cur_connect = models.DateTimeField(blank=True, null=True)
    # putvalid_beg = models.DateTimeField(blank=True, null=True)
    # putvalid_end = models.DateTimeField(blank=True, null=True)
    # acqvalid_beg = models.CharField(max_length=45, blank=True, null=True)
    # acqvalid_end = models.CharField(max_length=45, blank=True, null=True)
    # quota = models.FloatField(blank=True, null=True)
    # quota_rea = models.FloatField(blank=True, null=True)
    # u_priority = models.IntegerField(blank=True, null=True)
    # p_priority = models.IntegerField(blank=True, null=True)
    # dir_level = models.IntegerField(blank=True, null=True)
    # can_del_void_req = models.BooleanField(default=False)

    validator = models.ForeignKey(
        "PyrosUser", on_delete=models.DO_NOTHING, null=True, related_name="pyros_users")
    referee_themes = models.ManyToManyField(
        "ScienceTheme", related_name="referee_themes", blank=True)

    objects = PyrosUserManager()

    class Meta:
        managed = True
        db_table = 'pyros_user'

    def __str__(self):
        return (str(self.get_username()))

    def user_username(self):
        return self.__str__()
    user_username.short_description = "Username"

    def get_priority(self) -> int:

        """
        return maximum priority of all roles of the user

        Returns:
            int: maximum priority
        """

        return PyrosUser.objects.get(id=self.id).user_level.all().aggregate(Max("priority"))["priority__max"]

    def get_roles_str(self) -> str:

        """
        return string that represent all roles assigned to the user

        Returns:
            str: string of all roles assigned to user
        """
        roles_str = ""
        # loop on all roles assigned to user

        for role in PyrosUser.objects.get(id=self.id).user_level.all():
            roles_str += role.name + ", "

        return roles_str[:-2]

    def get_list_of_roles(self) -> list:

        """
        return list of all roles assigned to the user

        Returns:
            list: list of all roles assigned to user
        """

        return PyrosUser.objects.get(id=self.id).user_level.all().values_list("name", flat=True)

    # Note for the next functions : We take the first result of the query because it should be only one result with the filter applied since each UserLevel has a unique priority.

    def get_max_priority_desc(self) -> str:

        """
        return the desc of the maximum priority of all roles assigned to user

        Returns:
            str:  desc of the maximum priority of all roles assigned to user
        """

        return PyrosUser.objects.get(id=self.id).user_level.filter(priority=self.get_priority())[0].desc

    def get_max_priority_quota(self) -> int:

        """
        return the quota of the maximum priority of all roles assigned to user

        Returns:
            int:  quota of the maximum priority of all roles assigned to user
        """

        return PyrosUser.objects.get(id=self.id).user_level.filter(priority=self.get_priority())[0].quota

    def get_referee_themes_as_str(self) -> str:

        """
        Return the list of science themes associated to that user if user is a TAC.
        Return empty string otherwise

        Returns:
            str: list of science themes associated to that user
        """
        str = ""
        if self.referee_themes != None:

            for science_theme in PyrosUser.objects.get(id=self.id).referee_themes.all():
                str += science_theme.name + ", "

            return str[:-2]
        else:
            return str

    def get_scientific_program(self) -> QuerySet:

        sp_where_user_is_sp_pi = ScientificProgram.objects.filter(
            sp_pi=self.id)
        other_sp_of_user = ScientificProgram.objects.filter(id__in=SP_Period.objects.filter(id__in=SP_Period_User.objects.filter(
            user=PyrosUser.objects.get(username=self.username)).values("SP_Period")).values_list("scientific_program", flat=True))

        sp_of_user = sp_where_user_is_sp_pi | other_sp_of_user
        return sp_of_user

    def get_scientific_program_where_user_is_sp_pi(self) -> QuerySet:

        sp_where_user_is_sp_pi = ScientificProgram.objects.filter(
            sp_pi=self.id)

        return sp_where_user_is_sp_pi

# class Schedule(models.Model):
#     created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
#     plan_start = models.DecimalField(
#         default=0.0, max_digits=15, decimal_places=8)
#     plan_end = models.DecimalField(
#         default=0.0, max_digits=15, decimal_places=8)
#     flag = models.CharField(max_length=45, blank=True, null=True)
#
#     class Meta:
#         managed = True
#         db_table = 'schedule'
#
#     def __str__(self):
#         return (str(self.created))


class Schedule(models.Model):
    sequences = models.ManyToManyField(
        'Sequence', through='ScheduleHasSequences', related_name='schedules')
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    plan_night_start = models.DecimalField(
        default=0.0, max_digits=15, decimal_places=8)
    plan_end = models.DecimalField(
        default=0.0, max_digits=15, decimal_places=8)
    plan_start = models.DecimalField(
        default=0.0, max_digits=15, decimal_places=8)
    flag = models.CharField(max_length=45, blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'schedule'
        verbose_name_plural = "Schedules"

    def __str__(self):
        return (str(self.created))

class PeriodManager(models.Manager):

    # to get the currently active period, use exploitation_period()

    def currently_active_period(self) -> QuerySet:

        today = timezone.now().date()

        return Period.objects.get(start_date__lte=today, end_date__gt=today)

    def submission_periods(self) -> QuerySet:

        today = timezone.now().date()
        submission_periods_id = []
        periods = Period.objects.filter(start_date__gte=today)
        for period in periods:

            if period.submission_start_date <= today and period.submission_end_date > today:
                submission_periods_id.append(period.id)
        periods = periods.filter(id__in=submission_periods_id)
        return periods

    def evaluation_periods(self) -> QuerySet:

        today = timezone.now().date()
        evaluation_periods_id = []
        periods = Period.objects.filter(start_date__gte=today)
        for period in periods:
            if period.submission_end_date <= today and period.unit_pi_validation_start_date > today:
                evaluation_periods_id.append(period.id)
        periods = periods.filter(id__in=evaluation_periods_id)
        return periods

    def validation_periods(self) -> QuerySet:

        today = timezone.now().date()
        validation_periods_id = []
        periods = Period.objects.filter(start_date__gte=today)
        for period in periods:

            if period.unit_pi_validation_start_date <= today and period.notification_start_date > today:

                validation_periods_id.append(period.id)
        periods = periods.filter(id__in=validation_periods_id)
        return periods

    def notification_periods(self) -> QuerySet:

        today = timezone.now().date()
        notification_periods_id = []
        periods = Period.objects.filter(start_date__gte=today)
        for period in periods:

            if period.notification_start_date <= today and period.start_date > today:

                notification_periods_id.append(period.id)
        periods = periods.filter(id__in=notification_periods_id)
        return periods

    def exploitation_period(self) -> any:

        today = timezone.now().date()
        periods = Period.objects.filter(start_date__lte=today)
        for period in periods:
            if period.start_date <= today and period.end_date > today:
                return period
        return None

    def latest_period(self) -> any:

        today = timezone.now().date()

        future_period = Period.objects.filter(
            start_date__gt=today).order_by("-start_date").first()

        if future_period is None:
            # no future period defined so we return the current period
            return self.exploitation_period()
        return future_period

    def previous_periods(self) -> any:

        today = timezone.now().date()

        previous_periods = Period.objects.filter(start_date__lt=today).order_by(
            "-start_date").exclude(id=self.exploitation_period().id)

        return previous_periods

    def next_period(self) -> any:

        current_period = self.exploitation_period()

        next_period = Period.objects.filter(
            start_date__gt=current_period.start_date).order_by("start_date").first()

        return next_period

class Period(models.Model):

    # if change of default value, those values need to be changed also in create_period and edit_period.html (Javascript )
    today = timezone.now().date()

    today_plus_six_months = today + relativedelta(months=+6)

    today_minus_six_months = today + relativedelta(months=-6)

    today_minus_one_month_and_half = today + \
        relativedelta(months=-1) + relativedelta(days=-15)

    today_minus_fifteen_days = today + relativedelta(days=-15)
    end_date_plus_one_year = today_plus_six_months + relativedelta(years=+1)

    end_date_plus_eleven_year = today_plus_six_months + \
        relativedelta(years=+11)

    start_date = models.DateField(
        blank=True, null=True, default=timezone.now, editable=True)

    exploitation_duration = models.PositiveIntegerField(
        blank=True, null=True, default=182, editable=True)
    submission_duration = models.PositiveIntegerField(
        blank=True, null=True, default=136, editable=True)
    evaluation_duration = models.PositiveIntegerField(
        blank=True, null=True, default=31, editable=True)
    validation_duration = models.PositiveIntegerField(
        blank=True, null=True, default=5, editable=True)
    notification_duration = models.PositiveIntegerField(
        blank=True, null=True, default=10, editable=True)
    property_of_data_duration = models.PositiveIntegerField(
        blank=True, null=True, default=365, editable=True)
    data_accessibility_duration = models.PositiveIntegerField(
        blank=True, null=True, default=365*10, editable=True)

    @property
    def end_date(self):
        return self.start_date + relativedelta(days=self.exploitation_duration)

    @property
    def submission_start_date(self):

        return self.start_date + relativedelta(days=-(self.submission_duration+self.evaluation_duration+self.validation_duration+self.notification_duration))

    @property
    def submission_end_date(self):

        return self.submission_start_date + relativedelta(days=self.submission_duration)

    @property
    def unit_pi_validation_start_date(self):

        return self.submission_end_date + relativedelta(days=self.evaluation_duration)

    @property
    def notification_start_date(self):

        return self.unit_pi_validation_start_date + relativedelta(days=self.validation_duration)

    @property
    def property_of_data_end_date(self):
        return self.end_date + relativedelta(days=self.property_of_data_duration)

    @property
    def data_accessibility_end_date(self):
        return self.end_date + relativedelta(days=self.data_accessibility_duration)

    """
    end_date =  models.DateField(blank=True, null=True, default=start_date_plus_six_months,editable=True)    

    submission_start_date = models.DateField(blank=True, null=True, default=today_minus_six_months,editable=True)    
    submission_end_date = models.DateField(blank=True, null=True, default=today_minus_one_month_and_half,editable=True)    
    unit_pi_validation_start_date = models.DateField(blank=True, null=True, default=today_minus_fifteen_days,editable=True)    
    property_of_data_end_date = models.DateField(blank=True, null=True, default=end_date_plus_one_year,editable=True)     
    data_accessibility_end_date = models.DateField(blank=True, null=True, default=end_date_plus_eleven_year,editable=True)    

    
    #class Meta:

        # constrains start_date and duration to be unique (We don't want to have multiple records in db that represent the same period)

    #    constraints = [
    #        models.UniqueConstraint(fields=["start_date","duration"], name="unique_period")   
    #    ]

    """

    objects = PeriodManager()

    def __str__(self) -> str:

        return "P"+str(self.id)+" ("+self.start_date.strftime("%d/%m/%Y") + " to " + self.end_date.strftime("%d/%m/%Y")+")"

    def is_currently_active(self) -> bool:

        today = timezone.now().date()

        return self.start_date <= today < self.end_date

    def can_submit_sequence(self) -> bool:
        today = timezone.now().date()
        return today >= self.notification_start_date

    class Meta:
        db_table = "period"

class ScientificProgramManager(models.Manager):
    def observable_programs(self):
        exploitable_sp = []

        for sp_period in SP_Period.objects.all():
            if sp_period.can_submit_sequence():

                exploitable_sp.append(sp_period.scientific_program.id)

        return ScientificProgram.objects.filter(id__in=exploitable_sp)

class ScientificProgram(models.Model):

    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    name = models.CharField(max_length=30, blank=False,
                            null=False, default="", unique=True)
    description_short = models.TextField(default="", max_length=320)

    description_long = models.TextField(default="")

    institute = models.ForeignKey(
        Institute, on_delete=models.DO_NOTHING, related_name="scientific_programs")
    sp_pi = models.ForeignKey(
        "PyrosUser", on_delete=models.DO_NOTHING, related_name="Scientific_Program_Users")
    science_theme = models.ForeignKey(
        "ScienceTheme", on_delete=models.DO_NOTHING, related_name="scientific_program_theme", default=1)

    is_auto_validated = models.BooleanField(default=False)

    objects = ScientificProgramManager()

    class Meta:
        managed = True
        db_table = 'scientific_program'

    def __str__(self):
        return (str(self.name))

class SP_Period(models.Model):

    STATUSES_DRAFT = "Draft"
    STATUSES_SUBMITTED = "Submitted"
    STATUSES_EVALUATED = "Evaluated"
    STATUSES_ACCEPTED = "Accepted"
    STATUSES_REJECTED = "Rejected"
    STATUSES = [

        (STATUSES_DRAFT, "Draft"),
        (STATUSES_SUBMITTED, "Submitted"),
        (STATUSES_EVALUATED, "Evaluated"),
        (STATUSES_ACCEPTED, "Accepted"),
        (STATUSES_REJECTED, "Rejected")

    ]
    VOTES_YES = "A: Accepted"
    VOTES_NO = "C: Refused"
    VOTES_TO_DISCUSS = "B: To be discussed"
    VOTES = [

        (VOTES_YES, "A: Accepted"),
        (VOTES_TO_DISCUSS, "B: To be discussed"),
        (VOTES_NO, "C: Refused")

    ]
    IS_VALID_ACCEPTED = "Accepted"
    IS_VALID_REJECTED = "Rejected"
    IS_VALID = [

        (IS_VALID_ACCEPTED, "Accepted"),
        (IS_VALID_REJECTED, "Rejected")

    ]

    VISIBILITY_YES = "Yes"
    VISIBILITY_NO = "No"
    VISIBILITY_CHOICES = [

        (VISIBILITY_YES, "Yes"),
        (VISIBILITY_NO, "No"),

    ]

    period = models.ForeignKey(
        Period, on_delete=models.DO_NOTHING, related_name="SP_Periods")
    scientific_program = models.ForeignKey(
        ScientificProgram, on_delete=models.DO_NOTHING, related_name="SP_Periods")
    public_visibility = models.TextField(
        choices=VISIBILITY_CHOICES, default=VISIBILITY_YES)
    referee1 = models.ForeignKey(
        PyrosUser, on_delete=models.DO_NOTHING, related_name="TAC1_judgement", null=True)
    vote_referee1 = models.TextField(
        choices=VOTES, default=VOTES_YES, blank=True)

    reason_referee1 = models.TextField(blank=True)

    referee2 = models.ForeignKey(
        PyrosUser, on_delete=models.DO_NOTHING, related_name="TAC2_judgement", null=True)
    vote_referee2 = models.TextField(
        choices=VOTES, default=VOTES_YES, blank=True)

    reason_referee2 = models.TextField(blank=True)

    is_valid = models.TextField(
        choices=IS_VALID, default=IS_VALID_REJECTED, blank=True)
    status = models.TextField(choices=STATUSES, default=STATUSES_DRAFT)

    quota_minimal = models.PositiveIntegerField(default=0)
    quota_nominal = models.PositiveIntegerField(default=0)

    quota_allocated = models.PositiveIntegerField(default=0, blank=True)
    quota_remaining = models.PositiveIntegerField(default=0, blank=True)

    over_quota_duration = models.PositiveIntegerField(default=0)

    over_quota_duration_allocated = models.PositiveIntegerField(
        default=0, blank=True)
    over_quota_duration_remaining = models.PositiveIntegerField(default=0)

    token = models.PositiveIntegerField(default=0)

    token_allocated = models.PositiveIntegerField(default=0, blank=True)
    token_remaining = models.PositiveIntegerField(default=0, blank=True)
    priority = models.PositiveIntegerField(default=0, blank=True)

    def is_currently_active(self):
        return self.period.is_currently_active()

    def can_submit_sequence(self) -> bool:
        return self.is_currently_active() or self.period.can_submit_sequence() and self.status == self.STATUSES_ACCEPTED

    class Meta:
        db_table = "sp_period"

class SP_Period_User(models.Model):

    SP_Period = models.ForeignKey(
        SP_Period, on_delete=models.DO_NOTHING, related_name="SP_Period_Users")
    user = models.ForeignKey(
        "PyrosUser", on_delete=models.CASCADE, related_name="SP_Period_Users")

    #is_SP_PI = models.BooleanField(default=False)

    class Meta:
        unique_together = ('SP_Period', 'user')

        db_table = "sp_period_user"

class SP_Period_Guest(models.Model):

    SP_Period = models.ForeignKey(
        SP_Period, on_delete=models.DO_NOTHING, related_name="SP_Period_Guests")

    email = models.EmailField(max_length=254)

    class Meta:
        db_table = "sp_period_guest"

class SP_PeriodWorkflow(models.Model):
    SUBMISSION = "SUB"
    EVALUATION = "EVAL"
    VALIDATION = "VALI"
    NOTIFICATION = "NOTI"
    ACTIONS_CHOICES = (

        (SUBMISSION, "Submission"),
        (EVALUATION, "Evaluation"),
        (VALIDATION, "Validation"),
        (NOTIFICATION, "Notification")

    )

    action = models.CharField(max_length=120, choices=ACTIONS_CHOICES)
    period = models.ForeignKey(
        "Period", on_delete=models.DO_NOTHING, related_name="SP_Period_Workflows")

    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)

    class Meta:
        db_table = "sp_period_workflow"

class Sequence(models.Model):

    """ Definition of Status enum values """

    INVALID = "INVL"
    DRAFT = "DRAFT"

    # INCOMPLETE = "INCPL"
    # COMPLETE = "CPL"

    TOBEPLANNED = "TBP"
    PLANNED = "PLND"

    UNPLANNABLE = "UNPLN"

    REJECTED = "RJTD"

    REC_RUNNING = "RUN"
    REC_FINISHED = "EXD"
    REC_CANCELED = "CNCLD"
    PROC_RUNNING = "PROC_RUN"
    PROC_CANCELED = "PROC_CNCLD"
    PROC_FINISHED = "PROC_EXD"
    # PENDING = "PNDG"
    # EXECUTING = "EXING"
    # EXECUTED = "EXD"

    CANCELLED = "CNCLD"

    STATUS_CHOICES = (

        (INVALID, "Invalid"),
        (DRAFT, "DRAFT"),

        (TOBEPLANNED, "To be planned"),
        (PLANNED, "Planned"),
        (UNPLANNABLE, "Unplannable"),

        (REJECTED, "Rejected"),

        (REC_RUNNING, "Recording running"),

        (REC_FINISHED, "Recording finished"),

        (REC_CANCELED, "Recording canceled"),
        (PROC_RUNNING, "Processing running"),
        (PROC_FINISHED, "Processing finished"),
        (PROC_CANCELED, "Processing canceled"),

        (CANCELLED, "Cancelled"),

    )
    START_EXPO_PREF_CHOICES = (
        ('IMMEDIATE', 'IMMEDIATE'),
        ('BEST_ELEVATION', 'BEST_ELEVATION'),
        ('NO_CONSTRAINT', 'NO_CONSTRAINT'),

    )

    start_expo_pref = models.CharField(max_length=50, blank=False, null=True,
                                       choices=START_EXPO_PREF_CHOICES, default=START_EXPO_PREF_CHOICES[0])
    # request = models.ForeignKey(

    #    Request, on_delete=models.CASCADE, related_name="sequences")
    pyros_user = models.ForeignKey(

        'PyrosUser', on_delete=models.DO_NOTHING, related_name="sequences", blank=True, null=True)

    scientific_program = models.ForeignKey(
        'ScientificProgram', on_delete=models.DO_NOTHING, related_name="sequences", blank=True, null=True)

    name = models.CharField(max_length=45, blank=True, null=True, unique=True)

    desc = models.TextField(blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)

    last_modified_by =  models.ForeignKey(
        'PyrosUser', on_delete=models.DO_NOTHING, related_name="+", blank=True, null=True)

    is_alert = models.BooleanField(default=False)
    status = models.CharField(
        max_length=11, blank=True, null=True, choices=STATUS_CHOICES)
    target_coords = models.CharField(max_length=100, blank=True, null=True)
    with_drift = models.BooleanField(default=False)
    priority = models.IntegerField(blank=True, null=True)
    analysis_method = models.CharField(max_length=45, blank=True, null=True)
    moon_min = models.IntegerField(blank=True, null=True)
    alt_min = models.IntegerField(blank=True, null=True)
    type = models.CharField(max_length=6, blank=True, null=True)
    img_current = models.CharField(max_length=45, blank=True, null=True)
    img_total = models.CharField(max_length=45, blank=True, null=True)
    not_obs = models.BooleanField(default=False)
    obsolete = models.BooleanField(default=False)
    processing = models.BooleanField(default=False)
    flag = models.CharField(max_length=45, blank=True, null=True)

    period = models.ForeignKey(
        "Period", on_delete=models.DO_NOTHING, related_name="sequences", blank=True, null=True)

    start_date = models.DateTimeField(
        blank=True, null=True, default=timezone.now, editable=True)
    end_date = models.DateTimeField(
        blank=True, null=True, default=timezone.now, editable=True)
    # jd1 et jd2 = julian day start / end

    jd1 = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
    jd2 = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)

    tolerance_before = models.CharField(
        max_length=50, default="1s", blank=True, null=True)
    tolerance_after = models.CharField(
        max_length=50, default="1min", blank=True, null=True)

    #t_prefered = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)

    duration = models.DecimalField(
        default=-1.0, max_digits=15, decimal_places=8)

    # décomposer duration en duration pointing + duration album

    overhead = models.DecimalField(default=0, max_digits=15, decimal_places=8)

    submitted = models.BooleanField(default=False)

    config_attributes = models.JSONField(blank=True, null=True)

    ra = models.FloatField(blank=True, null=True)
    dec = models.FloatField(blank=True, null=True)

    complete = models.BooleanField(default=False, null=True, blank=True)

    class Meta:
        managed = True
        db_table = 'sequence'

    def __str__(self):
        return (str(self.name))


class ScheduleHasSequences(models.Model):
    # (EP) TODO: C'est pas un pb d'utiliser 2 fois le meme nom "shs" pour 2 choses differentes ???!!!
    schedule = models.ForeignKey(
        'Schedule', on_delete=models.CASCADE, related_name="shs")
    sequence = models.ForeignKey(
        'Sequence', on_delete=models.CASCADE, related_name="shs")

    status = models.CharField(
        max_length=11, blank=True, null=True, choices=Sequence.STATUS_CHOICES)
    desc = models.CharField(max_length=45, blank=True, null=True)
    tsp = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
    tep = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
    deltaTL = models.DecimalField(
        default=-1.0, max_digits=15, decimal_places=8)
    deltaTR = models.DecimalField(
        default=-1.0, max_digits=15, decimal_places=8)

    class Meta:
        managed = True
        db_table = 'schedule_has_sequences'


class SiteWatch(models.Model):
    OPEN = "OPEN"
    CLOSE = "CLOSE"
    ON = "ON"
    OFF = "OFF"

    global_status = models.CharField(max_length=255, blank=True, null=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    lights = models.CharField(max_length=45, blank=True, null=True)
    dome = models.CharField(max_length=45, blank=True, null=True)
    doors = models.CharField(max_length=45, blank=True, null=True)
    temperature = models.FloatField(blank=True, null=True)
    shutter = models.FloatField(blank=True, null=True)
    pressure = models.FloatField(blank=True, null=True)
    humidity = models.FloatField(blank=True, null=True)

    power_input = models.IntegerField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'sitewatch'
        verbose_name_plural = "Site watches"

    def __str__(self):
        return (str(self.__dict__))

    # TODO
    def setGlobalStatus(self):
        self.global_status = ""
        if self.doors and self.doors.find("open") != -1:
            self.global_status += "DOOR_OPEN "
        if self.lights and self.lights == "on":
            self.global_status += "LIGHTS_ON "
        if self.temperature and float(self.temperature) > 40:
            self.global_status += "TOO_HOT "
        if self.humidity and float(self.humidity) > 80:
            self.global_status += "HUMIDITY_TOO_HIGH "
        if self.global_status == "":
            self.global_status = "OK"
        return 0

    # TODO HANDLE FLAT LAMPS ...
    def setAttribute(self, key, value):
        self.doors = ""
        if key == "InsideHumidity":
            self.humidity = value
        elif key == "Pressure":
            self.pressure = value
        elif key == "InsideTemp":
            self.temperature = value

        elif key == "Roof_state":
            self.dome = value
        elif key == "Power_input":

            self.power_input = value

        else:
            return 1
        return 0


class SiteWatchHistory(models.Model):
    id = models.IntegerField(primary_key=True)

    class Meta:
        managed = True
        db_table = 'sitewatchhistory'
        verbose_name_plural = "Site watch histories"


class StrategyObs(models.Model):
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    xml_file = models.CharField(max_length=45, blank=True, null=True)
    is_default = models.BooleanField(default=False)

    class Meta:
        managed = True
        db_table = 'strategyobs'
        verbose_name_plural = "Strategy obs"

    def __str__(self):
        return (str(self.name))

# TODO: à virer car utilisé pour Celery (ou bien à utiliser pour les agents)

class TaskId(models.Model):
    task = models.CharField(max_length=45, blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    task_id = models.CharField(max_length=45, blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'task_id'

    def __str__(self):
        return (str(self.task) + " - " + str(self.task_id))

class Telescope(Device):
    TELESCOPE = "Telescope"

    mount_type = models.CharField(max_length=9, blank=True, null=True)
    diameter = models.FloatField(blank=True, null=True)
    latitude = models.FloatField(blank=True, null=True)
    longitude = models.FloatField(blank=True, null=True)
    sens = models.CharField(max_length=1, blank=True, null=True)
    altitude = models.FloatField(blank=True, null=True)
    readout_time = models.IntegerField(blank=True, null=True)
    slew_time = models.IntegerField(blank=True, null=True)
    slew_dead = models.IntegerField(blank=True, null=True)
    slew_rate_max = models.FloatField(blank=True, null=True)
    horizon_type = models.CharField(max_length=45, blank=True, null=True)
    horizon_def = models.FloatField(blank=True, null=True)
    lim_dec_max = models.FloatField(blank=True, null=True)
    lim_dec_min = models.FloatField(blank=True, null=True)
    lim_ha_rise = models.FloatField(blank=True, null=True)
    lim_ha_set = models.FloatField(blank=True, null=True)
    address = models.CharField(max_length=45, blank=True, null=True)
    night_elev_sun = models.FloatField(blank=True, null=True)
    mpc_code = models.CharField(max_length=45, blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'telescope'

    def __str__(self):
        return (self.name)


class TelescopeCommand(models.Model):
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    answered = models.DateTimeField(blank=True, null=True)
    request = models.CharField(blank=False, null=False, max_length=255)
    answer = models.TextField(null=True, blank=True)

    class Meta:
        managed = True
        db_table = "telescopecommand"

    def __str__(self):
        return str(self.request) + str(self.created)


class UserLevel(models.Model):
    name = models.CharField(max_length=45, blank=True, null=True)
    desc = models.TextField(blank=True, null=True)
    priority = models.IntegerField(blank=True, null=True)
    quota = models.FloatField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'user_level'

    def __str__(self):
        return (str(self.name))


class Version(models.Model):
    module_name = models.CharField(max_length=45, blank=True, null=True)
    version = models.CharField(max_length=15, blank=True, null=True)
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)

    class Meta:
        managed = True
        db_table = 'version'

    def __str__(self):
        return (str(self.module_name) + " - " + str(self.version))


class WeatherWatch(models.Model):
    WIND_LIMIT = 100
    RAIN_LIMIT = 5

    global_status = models.CharField(max_length=255, blank=True, null=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    humidity = models.FloatField(blank=True, null=True)
    wind = models.FloatField(blank=True, null=True)
    wind_dir = models.CharField(max_length=45, blank=True, null=True)
    temperature = models.FloatField(blank=True, null=True)
    pressure = models.FloatField(blank=True, null=True)
    rain = models.FloatField(blank=True, null=True)
    cloud = models.FloatField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'weatherwatch'
        verbose_name_plural = "Weather watches"

    def __str__(self):
        return (str(self.__dict__))

    # TODO
    def setGlobalStatus(self):

        # print(self.rain)

        self.global_status = ""
        if self.rain and float(self.rain) > 0:
            self.global_status += "RAINING "
        if self.wind and float(self.wind) > 80:
            self.global_status += "WIND_TOO_STRONG "
        if self.humidity and float(self.humidity) > 80:
            self.global_status += "HUMIDITY_TOO_HIGH "
        if self.cloud and float(self.cloud) > 10:
            self.global_status += "TOO_MUCH_CLOUDY "
        if self.global_status == "":
            self.global_status = "OK"
        return 0

    def setAttribute(self, key, value):
        if key == "Rain_boolean":
            self.rain = value
        elif key == "_CloudRate":
            self.cloud = value
        elif key == "Wind_speed":
            self.wind = value
        elif key == "Wind_direction":
            self.wind_dir = value
        elif key == "Temperature_outside":
            self.temperature = value
        elif key == "Humidity_outside":
            self.humidity = value
        elif key == "_Pressure":
            self.pressure = value
        else:
            return 1
        return 0


class WeatherWatchHistory(models.Model):

    weather = models.ForeignKey('WeatherWatch', on_delete=models.DO_NOTHING, related_name="weatherhistory", null=True, blank=True)

    datetime = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    humid_int = models.FloatField(blank=True, null=True)
    humid_ext = models.CharField(max_length=45, blank=True, null=True)
    wind = models.CharField(max_length=45, blank=True, null=True)
    wind_dir = models.CharField(max_length=45, blank=True, null=True)
    temp_int = models.CharField(max_length=45, blank=True, null=True)
    temp_ext = models.CharField(max_length=45, blank=True, null=True)
    pressure = models.CharField(max_length=45, blank=True, null=True)
    rain = models.CharField(max_length=45, blank=True, null=True)
    dwn = models.CharField(max_length=45, blank=True, null=True)

    humidity = models.FloatField(blank=True, null=True)
    wind = models.FloatField(blank=True, null=True)
    wind_dir = models.CharField(max_length=45, blank=True, null=True)
    temperature = models.FloatField(blank=True, null=True)
    cloud = models.FloatField(blank=True, null=True)

    class Meta:
        managed = True
        db_table = 'weatherwatchhistory'
        verbose_name_plural = "Weather watch histories"

    def __str__(self):
        return (str(self.datetime))

    def setAttribute(self, key, value):
        if key == "Rain_boolean":
            self.rain = value
        elif key == "_CloudRate":
            self.cloud = value
        elif key == "Wind_speed":
            self.wind = value
        elif key == "Wind_direction":
            self.wind_dir = value
        elif key == "Temperature_outside":
            self.temperature = value
        elif key == "Humidity_outside":
            self.humidity = value
        elif key == "_Pressure":
            self.pressure = value
        else:
            return 1

        return 0

class Majordome(models.Model):
    created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
    updated = models.DateTimeField(blank=True, null=True, auto_now=True)
    # Software Modes
    AUTO_MODE = "AUTO"
    MANUAL_MODE = "MANUAL"
    SOFT_MODE_CHOICES = (
        (AUTO_MODE, 'Auto mode'),
        (MANUAL_MODE, 'Manual mode'),
    )
    DAY_MODE = "DAY"
    NIGHT_MODE = "NIGHT"
    OBS_MODE_CHOICES = (
        (DAY_MODE, "Day mode"),
        (NIGHT_MODE, "Night mode")
    )
    soft_mode = models.CharField(
        choices=SOFT_MODE_CHOICES,
        default=AUTO_MODE,
        max_length=15
    )
    
    obs_mode = models.CharField(
        choices = OBS_MODE_CHOICES,
        default = DAY_MODE,
        max_length=15
    )

    @classmethod
    def object(cls):
        return cls._default_manager.first() 

    def save(self, *args, **kwargs):
        self.pk = self.id = 1
        return super().save(*args, **kwargs)