from django.db import models

from pyrosapp.models import Schedule, Sequence, ScheduleHasSequences

from operator import attrgetter
from decimal import *

import time
from DateTime import DateTime

DEFAULT_PLAN_START = Decimal(2457485.250000)  # April 6th 2016, 18:00:00.0 UT
DEFAULT_PLAN_END = Decimal(2457485.916667)  # April 7th 2016, 10:00:00.0 UT

PRECISION = Decimal(0.0000000001)

SIMULATION = False

MAX_OVERHEAD = 25
MAX_OVERHEAD_JD = Decimal(MAX_OVERHEAD / (24 * 60 * 60))

REJECTED_QUOTA = "Insufficient quota"
REJECTED_ROOM = "Insufficient room for this sequence"

'''
    Note : the following functions are necessary due to a too-high precision of Decimal objects
'''

def is_nearby_equal(a: Decimal, b: Decimal, precision: Decimal=PRECISION):

    '''
        Compare the two decimal, according to the given precision
    '''
    return (True if abs(b - a) < PRECISION else False)

def is_nearby_sup_or_equal(a: Decimal, b: Decimal, precision: Decimal=PRECISION):

    '''
        Compare the two decimal, according to the given precision
    '''
    if (a > b):
        return True
    return (True if abs(b - a) < PRECISION else False)

def is_nearby_less_or_equal(a: Decimal, b: Decimal, precision: Decimal=PRECISION):

    '''
        Compare the two decimal, according to the given precision
    '''
    if (a < b):
        return True
    return (True if abs(b - a) < PRECISION else False)

class Interval:
    """
    Simple class that represents an interval of time
    Julian days should be used
    """

    def __init__(self, start, end):
        self._start = Decimal(start)
        self._end = Decimal(end)
        self.duration = Decimal(end - start)

    def __str__(self):

        print("[" + str(self.start) + " - " + str(self.end) + "]")

    def _get_start(self):
        return self._start

    def _set_start(self, start):
        if start > self._end:

            raise ValueError(
                "Cannot set start (%d): must be lower than end (%d)" % (start, self._end))

        self._start = start
        self.duration = self._end - self._start

    def _get_end(self):
        return self._end

    def _set_end(self, end):
        if end < self._start:

            raise ValueError(
                "Cannot set end (%d): must be bigger than start (%d)" % (end, self._start))

        self._end = end
        self.duration = self._end - self._start

    start = property(fget=_get_start, fset=_set_start)
    end = property(fget=_get_end, fset=_set_end)

class Scheduler():
    """
   Role : create a planning for the following/current night

   Read in DB : Sequence, PyrosUser and parents
   Create in DB : Schedule

   Update in DB : Schedule, Sequence
   Delete in DB : None

   Entry point(s) :
           - make_schedule

           - simulate_schedule

    """

    """
    TODO:

        - définition de plan_start et plan_end
        - calcul de la priorité
        - calcul des quotas
        - définir l'attribut 'flag' de Schedule

        - remplissage des espaces libres

    """

    def __init__(self):

        self.schedule = Schedule.objects.create()

        # TODO: quel est le "flag" dans le schedule ??

        self.intervals = []

        self.max_overhead = MAX_OVERHEAD_JD

    def get_night_limits(self):
        '''
        determines and set plan_start and plan_end (beginning & end of the observation night)        
        '''

        # TODO: définir comment on calcule plan_start et plan_end (via quels
        # moyens)
        self.schedule.plan_start = DEFAULT_PLAN_START  # default value
        self.schedule.plan_end = DEFAULT_PLAN_END  # default value

    def set_night_limits(self, plan_start, plan_end):
        '''
        Sets given schedule start & end (in julian day)
        '''
        self.schedule.plan_start = Decimal(plan_start)
        self.schedule.plan_end = Decimal(plan_end)

    def make_schedule(self, first_schedule):

        '''
        ENTRY POINT

        Check all 'OBSERVABLE' sequences to create the most optimized planning for the following/current night

        It is assumed that all sequences that MUST and CAN be analyse have the OBSERVABLE status        

        shs means 'ScheduleHasSequences'
        self.sequences is a list of tuples (sequence, shs)
        
        :returns : The new schedule

        
        :side-effect :
            - modify sequences status and dates in DB
        '''

        global SIMULATION
        SIMULATION = False

        if first_schedule is False:
            self.copy_from_previous_schedule()
        else:
            self.schedule.plan_night_start = self.schedule.plan_start

        self.sequences = list(Sequence.objects.filter(status=Sequence.OBSERVABLE))

        shs_list = []
        for sequence in self.sequences:
            shs_list.append(ScheduleHasSequences(sequence=sequence, schedule=self.schedule))
        self.sequences = [(sequence, shs_list[index]) for index, sequence in enumerate(self.sequences)]

        self.compute_schedule()

        self.save_schedule()
        return self.schedule

    def copy_from_previous_schedule(self):

        '''

            Copy needed information from the previous schedule :
                - gets the executed sequences from the previous schedule and copy them into the new schedule
                - gets plan_start and plan_end
                - computes new plan_restart

            shs means 'ScheduleHasSequences'

        '''

        previous_sched = Schedule.objects.order_by('-created')[1]
        previous_exc_seq = previous_sched.sequences.filter(status=Sequence.EXECUTED)
        for seq in previous_exc_seq:
            shs = seq.shs
            shs.pk = None
            shs.schedule = self.schedule
            if SIMULATION == False:
                shs.save()

        self.schedule.plan_night_start = previous_sched.plan_night_start
        self.schedule.plan_end = previous_sched.plan_end

        ''' Schedule starts in MAX_OVERHEAD seconds '''

        self.schedule.plan_start = DateTime(time.time()).JulianDay() + self.max_overhead

    def simulate_schedule(self, sequences):
        '''
        ENTRY POINT - SIMULATION

        Do the same as make_schedule but do not touch the DB

        :type sequences : list of Sequence
        :param sequences : sequences to plan

        :returns : a tuple (Schedule, list of sequences)
        '''

        global SIMULATION
        SIMULATION = True

        self.schedule.plan_night_start = self.schedule.plan_start

        self.sequences = sequences

        shs_list = []
        for sequence in self.sequences:
            shs_list.append(ScheduleHasSequences(sequence=sequence, schedule=self.schedule))
        self.sequences = [(sequence, shs_list[index]) for index, sequence in enumerate(self.sequences)]

        self.compute_schedule()
        return (self.schedule, self.sequences)

    def compute_schedule(self):

        self.intervals.append(
            Interval(self.schedule.plan_start, self.schedule.plan_end))

        self.check_sequences_validity()

        self.determine_priorities()
        self.remove_not_eligible_sequences()
        self.sort_by_jd2_and_priorities()
        self.organize_sequences()

    def check_sequences_validity(self):
        '''
        Checks come sequence attributes to validate their integrity

        :side-effect :
            - remove invalid sequences from self.sequences
            - set INVALID status for invalid sequences in DB
        '''

        ''' Note(1) '''

        for sequence, shs in list(self.sequences):

            if sequence.jd1 < 0 or sequence.jd2 < 0 or is_nearby_less_or_equal(sequence.duration, 0) or sequence.jd2 - sequence.jd1 < sequence.duration:

                self.sequences.remove((sequence, shs))

                sequence.status = Sequence.INVALID

                if SIMULATION == False:
                    sequence.save()

    def determine_priorities(self):
        '''
        Computes sequences priority according to the user, the scientific program, ...        
        '''

        # TODO: définir comment on calcule la priorité
        pass

    def remove_not_eligible_sequences(self):
        '''
        Computes overlap between [jd1; jd2] and [plan_start; plan_end]
        Removes from self.sequences all the sequences that cannot be observed between plan_start and plan_end
        Set UNPLANNABLE sequences if jd2 < plan_start

        :side-effect :
            - remove unwanted sequences from self.sequences
        '''

        ''' Note (1) '''

        for sequence, shs in list(self.sequences):
            overlap = min(self.schedule.plan_end, sequence.jd2) - \
                max(self.schedule.plan_start, sequence.jd1) - self.max_overhead

            if overlap < sequence.duration:

                if sequence.jd1 < self.schedule.plan_start:

                    """ Note (2) """
                    sequence.status = Sequence.UNPLANNABLE

                    if SIMULATION == False:
                        sequence.save()

                self.sequences.remove((sequence, shs))

    def sort_by_jd2_and_priorities(self):
        '''
        Sort by priority and jd2, priority being the main sorting parameter        
        '''

        self.sequences.sort(key=lambda x: x[0].jd2)
        self.sequences.sort(key=lambda x: x[0].priority)

    def organize_sequences(self):
        '''
        Main function of the Scheduler
        Arrange a maximum of observable sequences in the planning

        Algorithm (for each sequence) :
            - check quota (remove sequence from list if quota is too low)
            - select matching intervals
            - IF matching intervals => place sequence according to tPrefered
            - IF NO matching intervals => try to move other sequences to place this one

        :side-effect :
            - remove unwanted sequences from self.sequences
            - change status and dates of sequences in self.sequences (but not in DB yet)
        '''

        ''' Note (1) '''
        for sequence, shs in list(self.sequences):

            quota = self.determine_quota(sequence)
            if quota < sequence.duration:

                shs.status = Sequence.REJECTED
                shs.desc = REJECTED_QUOTA

                continue

            matching_intervals = self.get_matching_intervals(sequence)
            if len(matching_intervals) > 0:

                self.place_sequence(sequence, shs, matching_intervals)

                sequence_placed = True
            else:

                sequence_placed = self.try_shifting_sequences(sequence, shs)

            if sequence_placed == True:

                shs.status = Sequence.PENDING

                self.update_quota(sequence)

            else:
                shs.status = Sequence.REJECTED
                shs.desc = REJECTED_ROOM

    def determine_quota(self, sequence: Sequence) -> float:

        '''
        Determines the quota (in minutes) according to the current planning duration and the quota of the user and scientific program associated

        :returns : The quota (float)
        '''
        # TODO: définir comment on calcule le quota

        return sequence.request.pyros_user.quota  # default value

    def get_matching_intervals(self, sequence: Sequence):

        '''
        Find the intervals where the sequence could be inserted

        :returns : list of matching Intervals
        '''

        matching_intervals = []

        for interval in self.intervals:

            overlap = min(sequence.jd2, interval.end) - \
                max(sequence.jd1, interval.start) - self.max_overhead

            if overlap > sequence.duration or is_nearby_equal(overlap, sequence.duration):

                matching_intervals.append(interval)

        return matching_intervals

    def place_sequence(self, sequence: Sequence, shs: ScheduleHasSequences, matching_intervals):

        '''
        Place the sequence in the better interval, according to the t_prefered

        :type matching_intervals: list [Interval]
        :param matching_intervals: Intervals in which the sequence can be placed

        :side-effect :
            - changes self.intervals
            - change the sequence if it it placed
        '''

        if len(matching_intervals) == 0:
            raise ValueError("matching_intervals shall not be empty")

        prefered_interval = self.get_prefered_interval(
            sequence, matching_intervals)
        sequence_position_in_interval = self.get_sequence_position_in_interval(
            sequence, prefered_interval)
        self.insert_sequence_in_interval(
            sequence, shs, prefered_interval, sequence_position_in_interval)
        self.cut_interval(sequence, shs, prefered_interval)
        self.update_other_deltas(sequence, shs, prefered_interval)

    def get_prefered_interval(self, sequence: Sequence, matching_intervals) -> Interval:

        '''

        Find the better interval, according to the t_prefered (get the nearest)

        :type matching_intervals: list [Interval]
        :param matching_intervals: Intervals in which the sequence can be placed

        :returns : An Interval that fits sequence.t_prefered at most
        '''

        if len(matching_intervals) == 0:
            raise ValueError("matching_intervals shall not be empty")

        if sequence.t_prefered == 0 or len(matching_intervals) == 1:

            prefered_interval = matching_intervals[0]
        else:
            for index, interval in enumerate(matching_intervals):

                if is_nearby_less_or_equal(interval.start, sequence.t_prefered) and is_nearby_less_or_equal(sequence.t_prefered, interval.end):

                    prefered_interval = interval
                    break
                elif sequence.t_prefered < interval.start:
                    if index == 0:
                        prefered_interval = interval

                    elif interval.start + self.max_overhead - sequence.t_prefered < sequence.t_prefered - matching_intervals[index - 1].end:
                        prefered_interval = interval

                    else:
                        prefered_interval = matching_intervals[index - 1]
                    break
        return prefered_interval

    def get_sequence_position_in_interval(self, sequence: Sequence, interval: Interval) -> str:

        '''
        Determines where the sequence will be inserted in the interval, regarding sequence.t_prefered

        :returns : A string in ["START", "END", "PREFERED"] describing where the sequence will be inserted in the interval
        '''

        if is_nearby_less_or_equal(interval.start, sequence.t_prefered) and is_nearby_less_or_equal(sequence.t_prefered, interval.end):
            if is_nearby_less_or_equal(sequence.t_prefered - Decimal(0.5) * sequence.duration, interval.start):

                position_in_interval = "START"

            elif is_nearby_sup_or_equal(sequence.t_prefered + Decimal(0.5) * sequence.duration, interval.end):

                position_in_interval = "END"
            else:

                position_in_interval = "PREFERED"

        else:
            if sequence.t_prefered < interval.start:
                position_in_interval = "START"
            else:
                position_in_interval = "END"
        return position_in_interval

    def insert_sequence_in_interval(self, sequence: Sequence, shs: ScheduleHasSequences, interval: Interval, position: str):

        '''
        Inserts the sequence in the interval:
            - sets sequence.tsp and sequence.tep
            - sets sequence.deltaTL and sequence.deltaTR

        :param interval: Interval in which the sequence will be inserted
        :param position: String describing where the sequence will be inserted in the interval

        :side-effect :
            - modify sequence attributes (tsp, tep, deltaTL, deltaTR)
        '''

        if position not in ["START", "END", "PREFERED"]:

            raise ValueError(
                "position must be either 'START', 'END' or 'PREFERED'")

        if position == "START":

            shs.tsp = max(
                interval.start + self.max_overhead, sequence.jd1)
            shs.tep = shs.tsp + sequence.duration
            shs.deltaTL = 0
            shs.deltaTR = min(
                interval.end, sequence.jd2) - shs.tep

        elif position == "END":

            shs.tep = min(interval.end, sequence.jd2)
            shs.tsp = shs.tep - sequence.duration
            shs.deltaTL = shs.tsp - \
                max(interval.start + self.max_overhead, sequence.jd1)
            shs.deltaTR = 0