import logging
from logging.handlers import RotatingFileHandler
from time import sleep
from threading import Thread, Event

from CoreLibrary.ExampleDriver import ExampleDriver
from CoreLibrary.ExampleSensor import ExampleSensor
from CoreLibrary.Measurement import Measurement
from CoreLibrary.Plot_Data import Plot_Data

LOGGER = logging.getLogger("my_logger")
LOGGER.setLevel(logging.DEBUG)
LOGGER.propagate = False

# create formatter
formatter = logging.Formatter('%(levelname)s %(asctime)s - %(module)s: %(message)s')

# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
LOGGER.addHandler(ch)

fi = RotatingFileHandler("my_logger.log", maxBytes=10**5, backupCount=5)
fi.setLevel(logging.DEBUG)
fi.setFormatter(formatter)
LOGGER.addHandler(fi)


class DataWorker(Thread):
    def __init__(self, pd):
        super().__init__(name="Data_Worker")
        self.exit_request = Event()
        self.pd = pd

    def run(self):
        while not self.exit_request.is_set():
            self.pd.refresh()
            sleep(1)


class Param_Model:
    def __init__(self):
        self.drivers = {"treib1": ExampleDriver()}
        self.sensors = {"mess1": ExampleSensor()}
        self.__plot_data = []
        self.__measurement = []
        self.data_worker = DataWorker(self)
        self.data_worker.start()

    def new_measurement(self, name=None, writer=None) -> Measurement:
        mess = Measurement(name=name)
        self.__measurement.append(mess)
        return mess

    def get_plot_data(self):
        plot_data = Plot_Data()
        self.__plot_data.append(plot_data)
        return plot_data

    def refresh(self):
        LOGGER.debug("refresh")
        for name, sens in self.sensors.items():
            data = sens.get_data
            for meas in self.__measurement:
                meas.append_data(name, data)
            for pd in self.__plot_data:
                pd.append_data(name, data)

    def stop_measuring(self):
        for sens in self.sensors.values():
            sens.stop_measuring()

    def start_measuring(self):
        for sens in self.sensors.values():
            sens.start_measuring()

    def exit(self):
        LOGGER.warning("entering exit method")
        for sens in self.sensors.values():
            sens.exit()
        for drv in self.drivers.values():
            drv.exit()
        self.data_worker.exit_request.set()