import logging
from datetime import datetime
from queue import Queue
from random import random
from threading import Thread, Event
from time import sleep

from Driver import Driver
from Sensor import Sensor

LOGGER = logging.getLogger("my_logger")


class ExampleDriverWorker(Thread):
    """Communicates with the measuring hardware. Here we only produce random data."""

    def __init__(self, message_queue):
        super().__init__(name="Measure")
        self.message_queue = message_queue
        self.produceData = Event()
        self.exit_request = Event()
        self.prev = 0

    def run(self):
        """Worker method of a python Thread. Called when the Thread is started."""
        while not self.exit_request.is_set():
            if self.produceData.is_set():
                temp = self.prev + random() / 100.0
                self.prev = temp
                ts = datetime.utcnow()
                self.message_queue.put((ts, temp))
            else:
                pass
            sleep(1)

class ExampleDriver(Driver, Sensor):
    """docstring for Model."""

    def __init__(self):
        super(Driver, self).__init__()
        self.measureQueue = Queue()
        self.measureThread = ExampleDriverWorker(self.measureQueue)
        self.measureThread.start()
        self.measureThread.produceData.set()
        self.speed = 10
        self.running = False

    def exit(self):
        self.measureThread.exit_request.set()

    def set_config(self, config: dict):
        self.speed = config["speed"]

    def get_config(self):
        return {"speed": self.speed}
        pass

    def get_status(self):
        return {"running": self.running}

    def start_measuring(self):
        self.measureThread.produceData.set()
        LOGGER.info("I started meas")

    def stop_measuring(self):
        self.measureThread.produceData.clear()
        LOGGER.info("I stopped meas")

    def exit(self):
        self.stop_measuring()
        self.measureThread.exit_request.set()

    @property
    def get_data(self):
        time = []
        val = []
        while not self.measureQueue.empty():
            t, data = self.measureQueue.get()
            time.append(t)
            val.append(data)
        return time, val