from datetime import datetime
from time import time

class Condition():
    def __init__(self, id, condition):
        self._id = id
        self._type = condition['type']
        self._comparsion = condition['comparsion']
        self._value = condition['value']
        self._active = False
    
    @property
    def id(self):
        return self._id

    @property
    def type(self):
        return self._type

    @property
    def comparsion(self):
        return self._comparsion

    @property
    def value(self):
        return self._value
    
    @id.setter
    def id(self, new_id):
        self._id = new_id
    
    @type.setter
    def type(self, new_type):
        self._type = new_type

    @comparsion.setter
    def comparsion(self, new_comparsion):
        self._comparsion = new_comparsion    
    
    @value.setter
    def value(self, new_value):
        self._value = new_value

    def compareWith(self, operator, x, y) -> bool:
        # print(operator, x, y)
        cases = {
            "equal": lambda a, b: a == b,
            "bigger": lambda a, b: a >= b,
            "smaller": lambda a, b: a <= b,
        }

        return cases[operator](x, y)

    def match_or_not(self, **kwargs):
        # print(self._type, self._comparsion, self._value)
        return getattr(self, self.type)(**kwargs)
       
    def absolute_time(self, **kwargs):
        # now = int(time())
        now = round(time(), 1)
        time_condition = round(self.datetime_to_timestamp(self.str_to_datetime(self._value)))

        return self.compareWith(self.comparsion, now, time_condition)

    def after_project_run(self, **kwargs):
        project_start_time = kwargs['project_start_time']
        delay_time = kwargs['delay_time']

        # time_diff = int(time() - project_start_time - delay_time)
        time_diff = round(time() - project_start_time - delay_time, 1)
        return self.compareWith(self.comparsion, time_diff, round(int(self._value), 1))
    
    def after_task_run(self, **kwargs):
        # print('relative_time_from_task', kwargs['task_start_time'],kwargs['delay_time'])
        if len(kwargs['task_start_time']) == 0:
            return False
        task = kwargs['self_task']
        running_task = kwargs['running_task']
        task_start_time = kwargs['task_start_time'][-1]
        delay_time = kwargs['delay_time']
        
        time_diff = round(time() - task_start_time - delay_time, 1)
        # print('real_diff', time() - task_start_time - delay_time)
        # print(task.name, task.uuid, time_diff, round(int(self._value), 1), running_task.name, running_task.uuid)
        # if round(int(self._value), 1) == 0 and time_diff == 0.1:
        #     return True
        if task.uuid != running_task.uuid:
            return False
        return self.compareWith('bigger', time_diff, round(int(self._value), 1))
        # return self.compareWith(self.comparsion, time_diff, round(int(self._value), 1))
    
    def device(self, **kwargs):
        print('device')
    
    """ def previous_task_done(self, **kwargs):
        running_task = kwargs['running_task']
        if running_task.status == 2 and self._active == False:
            self._active = True
            return True
        return False """

    def previous_task_done(self, **kwargs):
        running_task = kwargs['running_task']
        self_task = kwargs['self_task']
        # if running_task != None and self_task != None:
        # print('\nprevious_task_done: ', running_task.status, ' ', self._active)
        if running_task != self_task:
            if running_task == None:
                return True
            if running_task.status == 2 and self._active == False:
                # self._active = True
                return True
        return False

    def until_button_trigger(self, **kwargs):
        running_task = kwargs['running_task']
        if running_task != None:
            if running_task.button_trigger == True:
                running_task.button_trigger = False
                return True
        return False 
    
    """ def cycle(self, **kwargs):
        running_task = kwargs['running_task']
        self_task = kwargs['self_task']
        if running_task != self_task:
            if running_task.status == 2 and self._active == False:
                # self._active = True
                return True
        return False """

    def str_to_datetime(self, time_str):
        return datetime.strptime(time_str,'%Y-%m-%dT%H:%M')

    def datetime_to_timestamp(self, date):
        return datetime.timestamp(date)

    def as_json(self):
        return {
            'id': self._id,
            'type': self._type,
            'comparsion': self._comparsion,
            'value': self._value,
            'active': self._active
        }