hardware_serial = ubinascii.hexlify(machine.unique_id()).decode()
l99_serial = 'L99-{}'.format(hardware_serial)

def ble_connection_callback(is_connected):
    if is_connected:
        if _DEBUG: print('BLE connected')
        pycom.rgbled(_LED_BLUE)
    else:
        if _DEBUG: print('BLE disconnected')
        pycom.rgbled(_LED_GREEN)

ble = BLEGATTS()
ble.init(advert_name=l99_serial,
    advert_mfg_data='L99',
    advert_service_data=None,
    advert_service_uuid=6154,
    connect_callback=ble_connection_callback)

info = uos.uname()

ble.addService(service_name='device_info',uuid=6154) \
    .addReadChar (name='l99_serial', uuid=0, static_read=l99_serial) \
    .addReadChar (name='hardware_serial', uuid=1, static_read=hardware_serial) \
    .addReadChar (name='sysname', uuid=2, dynamic_read=lambda cn,id: info[0]) \
    .addReadChar (name='nodename', uuid=3, dynamic_read=lambda cn,id: info[1]) \
    .addReadChar (name='release', uuid=4, dynamic_read=lambda cn,id: info[2]) \
    .addReadChar (name='version_number', uuid=5, dynamic_read=lambda cn,id: info[3].split(' on ')[0]) \
    .addReadChar (name='version_date', uuid=6, dynamic_read=lambda cn,id: info[3].split(' on ')[1]) \
    .addReadChar (name='machine', uuid=7, dynamic_read=lambda cn,id: info[4]) \
    .addReadChar (name='lora_version', uuid=8, dynamic_read=lambda cn,id: info[5]) \
    .addReadChar (name='sx_state', uuid=9, static_read=sx_init[0]) \
    .addReadChar (name='sx_fault', uuid=10, static_read=sx_init[1]) \
    .addReadChar (name='ads1_state', uuid=11, static_read=ads1_init[0]) \
    .addReadChar (name='ads1_fault', uuid=12, static_read=ads1_init[1]) \
    .addReadChar (name='ads2_state', uuid=13, static_read=ads2_init[0]) \
    .addReadChar (name='ads2_fault', uuid=14, static_read=ads2_init[1]) \
    .start()

dService = ble.addService(service_name='datapoint_monitor',uuid=9999)
uuid_counter = 0
uuid_hw_label_offset = 100
uuid_user_label_offset = 200
uuid_value_offset = 300
char_hw_label_sfx = '+HL'
char_user_label_sfx = '+UL'
char_value_sfx = '+V'

dService.addReadChar(name='HLBase', uuid=1, static_read=uuid_hw_label_offset)
dService.addReadChar(name='ULBase', uuid=2, static_read=uuid_user_label_offset)
dService.addReadChar(name='VBase', uuid=3, static_read=uuid_value_offset)

for deviceKey, deviceDataPoints in sorted(dPool.devicePool.items()):
    for datapointKey, datapoint in sorted(deviceDataPoints.items()):

        dPool.addKey(datapoint,uuid_counter+uuid_hw_label_offset)
        dPool.addKey(datapoint,uuid_counter+uuid_user_label_offset)
        dPool.addKey(datapoint,uuid_counter+uuid_value_offset)

        bleCharName = '{}+{}'.format(deviceKey, datapointKey)

        dService.addReadChar(name='{}{}'.format(bleCharName,char_hw_label_sfx), uuid=uuid_counter+uuid_hw_label_offset,
            dynamic_read=lambda cn,id: dPool.getHardwareLabelName(id))

        dService.addReadWriteChar(name='{}{}'.format(bleCharName,char_user_label_sfx), uuid=uuid_counter+uuid_user_label_offset,
            dynamic_read=lambda cn,id: dPool.getUserLabelName(id),
            dynamic_write=lambda cn,id,val: dPool.setUserLabelName(id,val))

        ###if _DEBUG: print('BLEMAP 0x{:02x}/{:02d} => BLEUUID 0x{:02x} BLECHAR {}+V'.format(datapoint.bus_address, datapoint.hw_address,uuid_counter+uuid_value_offset, bleCharName))

        if datapoint.readonly:
            if datapoint.datatype == 'analog':
                # HACK: gotta turn to string before sending out
                dService.addReadNotifyChar(name='{}{}'.format(bleCharName,char_value_sfx), uuid=uuid_counter+uuid_value_offset,
                    dynamic_read=lambda cn,id: str(dPool.getHardwareValue(id)))
            else:
                dService.addReadNotifyChar(name='{}{}'.format(bleCharName,char_value_sfx), uuid=uuid_counter+uuid_value_offset,
                    dynamic_read=lambda cn,id: dPool.getHardwareValue(id))
        else:
            dService.addReadWriteNotifyChar(name='{}{}'.format(bleCharName,char_value_sfx), uuid=uuid_counter+uuid_value_offset,
                dynamic_read=lambda cn,id: dPool.getHardwareValue(id),
                dynamic_write=lambda cn,id,val: dPool.setHardwareValue(id,int.from_bytes(val,'little')))

        uuid_counter += 1

dService.start()

# update datapoints with current IO values
if sx_init[0]:
    for pin in range(0,16):
        dPool.updateHardwareValue(sx_config.address,pin,sx_inst.digitalRead(pin))

ble.advertise()