#!/usr/bin/python3.5

import sys
from btlewrap.bluepy import BluepyBackend

import json
import sys
import time
from btlewrap.base import BluetoothInterface, BluetoothBackendException

# sudo pip3 install bluepy; sudo pip3 install paho-mqtt; sudo pip3 install mitemp_bt

from datetime import datetime, timedelta
import logging
from threading import Lock
from btlewrap.base import BluetoothInterface, BluetoothBackendException

_HANDLE_READ_BATTERY_LEVEL = 0x0018
_HANDLE_READ_FIRMWARE_VERSION = 0x0024
_HANDLE_READ_NAME = 0x03
_HANDLE_READ_WRITE_SENSOR_DATA = 0x0010

# org/bluez/hci0/dev_00_81_E8_DE_B0_80/service0034/char003a
# 00:81:F9:DD:16:55

MI_TEMPERATURE = "temperature"
MI_HUMIDITY = "humidity"
MI_BATTERY = "battery"
MI_DATA = "data"

_LOGGER = logging.getLogger(__name__)


class MiTempBtPoller(object):
    """"
    A class to read data from Mi Temp plant sensors.
    """

    def __init__(self, mac, backend, cache_timeout=600, retries=3, adapter='hci0'):
        """
        Initialize a Mi Temp Poller for the given MAC address.
        """

        self._mac = mac
        self._bt_interface = BluetoothInterface(backend)
        self._cache = None
        self._cache_timeout = timedelta(seconds=cache_timeout)
        self._last_read = None
        self._fw_last_read = None
        self.retries = retries
        self.ble_timeout = 10
        self.lock = Lock()
        self._firmware_version = None
        self.battery = None

    def name(self):
        """Return the name of the sensor."""
        with self._bt_interface.connect(self._mac) as connection:
            name = connection.read_handle(_HANDLE_READ_NAME)  # pylint: disable=no-member

        if not name:
            raise BluetoothBackendException("Could not read NAME using handle %s"
                                            " from Mi Temp sensor %s" % (hex(_HANDLE_READ_NAME), self._mac))
        return ''.join(chr(n) for n in name)

    def read_some_stuff(self):
        """Read stuff"""
        if (self._firmware_version is None) or \
                (datetime.now() - timedelta(hours=24) > self._fw_last_read):
            self._fw_last_read = datetime.now()
            with self._bt_interface.connect(self._mac) as connection:
                res_firmware = connection.read_handle(_HANDLE_READ_FIRMWARE_VERSION)  # pylint: disable=no-member
                _LOGGER.debug('Received result for handle %s: %s',
                              _HANDLE_READ_FIRMWARE_VERSION, res_firmware)
                res_battery = connection.read_handle(_HANDLE_READ_BATTERY_LEVEL)  # pylint: disable=no-member
                _LOGGER.debug('Received result for handle %s: %d',
                              _HANDLE_READ_BATTERY_LEVEL, res_battery)

                res_temp = connection.read_handle(0x0022)
                  
                self.firmware_raw=res_firmware
                self.battery_raw=res_battery
                self.temp_raw=res_temp
        return self._firmware_version

# {"mac": "00:81:F9:DD:16:55", "firmware.raw": [192, 33, 0, 0], "battery.raw": [166, 163, 125, 153, 242, 111, 26, 138, 12, 75, 10, 122, 176, 204, 224, 235], "temp.raw": [16, 59, 0, 30, 42]}

mac = sys.argv[1]

print("babytemp");

while 1:
  try:
     poller = MiTempBtPoller(mac, BluepyBackend)
     poller.read_some_stuff();
     
     data = json.dumps({
         "mac": mac,
       "firmware.raw":list(poller.firmware_raw),
       "battery.raw":list(poller.battery_raw),
       "temp.raw":list(poller.temp_raw),
     })
     
     print(data)

  except BluetoothBackendException:
     data = json.dumps({
         "mac": mac,
         "error": 1,
         })
     print(data)
     time.sleep(30)
     
  time.sleep(5)