import time

from kube_hunter.conf import Config, set_config
from kube_hunter.core.types import Hunter
from kube_hunter.core.events.types import Event, Service
from kube_hunter.core.events.event_handler import handler

counter = 0
first_run = True

set_config(Config())


class OnceOnlyEvent(Service, Event):
    def __init__(self):
        Service.__init__(self, "Test Once Service")


class RegularEvent(Service, Event):
    def __init__(self):
        Service.__init__(self, "Test Service")


class AnotherRegularEvent(Service, Event):
    def __init__(self):
        Service.__init__(self, "Test Service (another)")


class DifferentRegularEvent(Service, Event):
    def __init__(self):
        Service.__init__(self, "Test Service (different)")


@handler.subscribe_once(OnceOnlyEvent)
class OnceHunter(Hunter):
    def __init__(self, event):
        global counter
        counter += 1


@handler.subscribe(RegularEvent)
class RegularHunter(Hunter):
    def __init__(self, event):
        global counter
        counter += 1


@handler.subscribe_many([DifferentRegularEvent, AnotherRegularEvent])
class SmartHunter(Hunter):
    def __init__(self, events):
        global counter, first_run
        counter += 1

        # we add an attribute on the second scan.
        # here we test that we get the latest event
        different_event = events.get_by_class(DifferentRegularEvent)
        if first_run:
            first_run = False
            assert not different_event.new_value
        else:
            assert different_event.new_value


@handler.subscribe_many([DifferentRegularEvent, AnotherRegularEvent])
class SmartHunter2(Hunter):
    def __init__(self, events):
        global counter
        counter += 1

        # check if we can access the events
        assert events.get_by_class(DifferentRegularEvent).__class__ == DifferentRegularEvent
        assert events.get_by_class(AnotherRegularEvent).__class__ == AnotherRegularEvent


def test_subscribe_mechanism():
    global counter
    counter = 0

    # first test normal subscribe and publish works
    handler.publish_event(RegularEvent())
    handler.publish_event(RegularEvent())
    handler.publish_event(RegularEvent())

    time.sleep(0.02)
    assert counter == 3


def test_subscribe_once_mechanism():
    global counter
    counter = 0

    # testing the multiple subscription mechanism
    handler.publish_event(OnceOnlyEvent())

    time.sleep(0.02)
    assert counter == 1
    counter = 0

    handler.publish_event(OnceOnlyEvent())
    handler.publish_event(OnceOnlyEvent())
    handler.publish_event(OnceOnlyEvent())
    time.sleep(0.02)

    assert counter == 0


def test_subscribe_many_mechanism():
    global counter
    counter = 0

    # testing the multiple subscription mechanism
    handler.publish_event(DifferentRegularEvent())
    handler.publish_event(DifferentRegularEvent())
    handler.publish_event(DifferentRegularEvent())
    handler.publish_event(DifferentRegularEvent())
    handler.publish_event(DifferentRegularEvent())
    handler.publish_event(AnotherRegularEvent())

    time.sleep(0.02)
    # We expect SmartHunter and SmartHunter2 to be executed once. hence the counter should be 2
    assert counter == 2
    counter = 0

    # Test using most recent event
    newer_version_event = DifferentRegularEvent()
    newer_version_event.new_value = True
    handler.publish_event(newer_version_event)

    assert counter == 2