from agent_util import total_seconds
from datetime import datetime, timedelta
import logging
import sys


class Anomaly(object):
    def __init__(self, acceptable_duration, schedules_number_of_checks):
        self.log = logging.getLogger(self.__class__.__name__)
        self.log.info('New anomaly detected')

        now = datetime.now()
        self.time_first_detected = now
        self.time_last_detected = now
        self.acceptable_duration = timedelta(seconds=acceptable_duration)
        self.reported_as_exceeded_duration = False
        self.reported_as_cleared = False
        self.schedules_number_of_checks = schedules_number_of_checks

    def __repr__(self):
        return '<%s, %s first detected: %s, last detected: %s, duration: %s>' % (
            self.__class__.__name__,
            self.reported_as_exceeded_duration and "PUSHED" or "WAITING",
            self.time_first_detected,
            self.time_last_detected,
            self.acceptable_duration,
        )

    # The logging library interferes with cPickle, so we must remove the logger
    # instance then reset it when we serialize/unserialize.
    def __getstate__(self):
        state = dict(self.__dict__)
        del state['log']
        return state

    def __setstate__(self, state):
        self.__dict__.update(state)
        self.log = logging.getLogger(self.__class__.__name__)

    def exceeds_duration(self):
        time_since_first_detection = (datetime.now() -
                                      self.time_first_detected)
        self.log.debug('Anomaly began %s and has lasted %s seconds',
                       self.time_first_detected,
                       total_seconds(time_since_first_detection))

        return time_since_first_detection >= self.acceptable_duration

    def has_cleared(self, current_check_number):
        time_since_last_detection = datetime.now() - self.time_last_detected
        self.log.debug('Anomaly was last detected at %s, %s seconds ago',
                       self.time_last_detected,
                       total_seconds(time_since_last_detection))

        return (time_since_last_detection > self.acceptable_duration and
                self.schedules_number_of_checks < current_check_number)