class oximeterController(MicroController):

    _characteristicsPath = "Characteristics/oximeterController.json"

    def Setup(self):
        self.bt = Battery(
            self._ControllerChar['Battery']['CurrentState']['Power'])
        self.ble = Bluetooth(3.0, 30)
        self.ts = oximeterSensor(3.0)

    def __init__(self):
        self.jsonHandler = JsonHandler()
        self._ControllerChar = self.jsonHandler.LoadJson(
            self._characteristicsPath)
        self.Setup()
        self.ConnectHandlers()
        super().__init__(3.0)

        try:
            while (True):
                self.Run()
        except KeyboardInterrupt:
            self._ControllerChar['Battery']['CurrentState'][
                'Power'] = self.bt.GetCurrentCharge()
            self.__del__()
            exit(1)

    def __del__(self):
        self.jsonHandler.WriteJson(self._characteristicsPath,
                                   self._ControllerChar)
        self.ble.__del__()
        self.ts.__del__()
        self.bt.__del__()
        super().__del__()

    def ConnectHandlers(self):
        self.ble._batteryEvent.addHandler(self.bt.Discharging)
        self.ts._batteryEvent.addHandler(self.bt.Discharging)
        self._batteryEvent.addHandler(self.bt.Discharging)

    def Run(self):
        time.sleep(3)
        temp = self.ReadOxygenLevel()
        #time.sleep(3)
        print("Oximeter---->" + str(temp))
        if (temp < 90):
            self.WriteBluetooth(temp)
        time.sleep(3)

    def ReadOxygenLevel(self):
        self.I2CRead()
        return self.ts.I2CRead()

    def WriteBluetooth(self, data):
        super().I2CWrite()
        data = str(data) + '| OxygenLevel'
        self.ble.Tx(data)
class EdgeNodeController(EdgeController):

    _characteristicsPath = "Characteristics/TemperatureController.json"

    def Setup(self):
        self.bt = Battery(
            self._ControllerChar['Battery']['CurrentState']['Power'])
        self.ble = Bluetooth(3.0, 30)
        self.ble.ToRxMode()

    def __init__(self):
        self.jsonHandler = JsonHandler()
        self._ControllerChar = self.jsonHandler.LoadJson(
            self._characteristicsPath)
        self.Setup()
        self.ConnectHandlers()
        self._mqttService = MqttPublisher("EdgeNode", "DS/Node1/Temperature")
        super().__init__(3.0)

        try:
            while (True):
                self.Run()
        except KeyboardInterrupt:
            self._ControllerChar['Battery']['CurrentState'][
                'Power'] = self.bt.GetCurrentCharge()
            self.__del__()
            exit(1)

    def __del__(self):
        self.jsonHandler.WriteJson(self._characteristicsPath,
                                   self._ControllerChar)
        self.ble.__del__()
        self.bt.__del__()
        super().__del__()

    def ConnectHandlers(self):
        self.ble._batteryEvent.addHandler(self.bt.Discharging)
        self._batteryEvent.addHandler(self.bt.Discharging)
        self.ble._uartEvent.addHandler(self.UartRx)

    def Run(self):
        pass

    def UartRx(self, **kwargs):
        data = kwargs.get('data')
        self.UartPowerConsumed(data)
        print('RX --->>>', str(data))
        self.WifiPowerConsumed(data)
        self._mqttService.Publish(data)
class TemperatureController(MicroController):

    checker = True

    def __init__(self):
        self.Setup()
        self.ConnectHandlers()
        super().__init__(3.0)

        try:
            while (self.checker):
                self.Run()
        except KeyboardInterrupt:
            self.__del__()
            exit(1)

    def __del__(self):
        self.ble.__del__()
        self.ts.__del__()
        self.bt.__del__()
        super().__del__()

    def ConnectHandlers(self):
        self.ble._batteryEvent.addHandler(self.bt.Discharging)
        self.ts._batteryEvent.addHandler(self.bt.Discharging)
        super()._batteryEvent.addHandler(self.bt.Discharging)

    def Setup(self):
        self.bt = Battery()
        self.ble = Bluetooth(3.0)
        self.ts = TemperatureSensor(3.0)

    def Run(self):
        time.sleep(3)
        temp = self.ReadTemperature()
        time.sleep(3)
        self.WriteBluetooth(temp)
        time.sleep(3)

    def ReadTemperature(self):
        super().I2CWrite()
        self.ts.I2CWrite()
        super().I2CRead()
        return self.ts.I2CRead()

    def WriteBluetooth(self, data):
        super().I2CWrite()
        self.ble.Tx(data)
 def Setup(self):
     self.bt = Battery(
         self._ControllerChar['Battery']['CurrentState']['Power'])
     self.ble = Bluetooth(3.0, 30)
     self.ts = oximeterSensor(3.0)
 def Setup(self):
     self.bt = Battery()
     self.ble = Bluetooth(3.0)
     self.ts = TemperatureSensor(3.0)
 def Setup(self):
     self.bt = Battery(
         self._ControllerChar['Battery']['CurrentState']['Power'])
     self.ble = Bluetooth(3.0, 30)
     self.ble.ToRxMode()
class EdgeNodeController(EdgeController):

    _characteristicsPath = "Characteristics/ECGController.json"

    def Setup(self):
        self.bt = Battery(
            self._ControllerChar['Battery']['CurrentState']['Power'])
        self.ble = Bluetooth(3.0, 30)
        self.ble.ToRxMode()

    def __init__(self):
        self.jsonHandler = JsonHandler()
        self._ControllerChar = self.jsonHandler.LoadJson(
            self._characteristicsPath)
        self.Setup()
        self.ConnectHandlers()
        self._mqttService = MqttPublisher("EdgeNode",
                                          "PatientMonitoring/Edge3/")
        super().__init__(3.0)

        try:
            while (True):
                self.Run()
        except KeyboardInterrupt:
            self._ControllerChar['Battery']['CurrentState'][
                'Power'] = self.bt.GetCurrentCharge()
            self.__del__()
            exit(1)

    def __del__(self):
        self.jsonHandler.WriteJson(self._characteristicsPath,
                                   self._ControllerChar)
        self.ble.__del__()
        self.bt.__del__()
        super().__del__()

    def ConnectHandlers(self):
        self.ble._batteryEvent.addHandler(self.bt.Discharging)
        self._batteryEvent.addHandler(self.bt.Discharging)
        self.ble._uartEvent.addHandler(self.UartRx)

    def Run(self):
        pass

    def Encript(self, data):
        password_provided = "password"  # This is input in the form of a string
        password = password_provided.encode()  # Convert to type bytes
        salt = b'salt_'  # CHANGE THIS - recommend using a key from os.urandom(16), must be of type bytes
        kdf = PBKDF2HMAC(algorithm=hashes.SHA256(),
                         length=32,
                         salt=salt,
                         iterations=100000,
                         backend=default_backend())
        key = base64.urlsafe_b64encode(
            kdf.derive(password))  # Can only use kdf once
        message = data.encode()

        f = Fernet(key)
        encrypted = f.encrypt(message)

        #print('RX --->>>', str(encrypted))
        return encrypted

    def UartRx(self, **kwargs):
        data = kwargs.get('data')
        self.UartPowerConsumed(data)
        print('RX --->>>', str(data))
        data = str(data).split('| ')
        #temp = int(data[0])
        encdata = self.Encript(data[0])
        self.WifiPowerConsumed(encdata)
        #if(temp>400 or temp<70):
        self._mqttService.Publish(encdata, data[1])