from bleak import BleakScanner  
  
TARGET_MAC = "A8:0B:6B:F4:23:38"  
  
def detection_callback(device, advertisement_data):  
   if device.address.upper() != TARGET_MAC:  
       return  
  
   mfg = advertisement_data.manufacturer_data  
   if not mfg:  
       return  
  
   print("---- SCALE UPDATE ----")  
   for company_id, data in mfg.items():  
       print(f"Company ID: {company_id}")  
       print(f"Raw Data: {data.hex()}")  
  
async def main():  
   scanner = BleakScanner(detection_callback)  
   await scanner.start()  
   print("Listening for scale updates...")  
   await asyncio.sleep(60)   # listen for 1 minute  
   await scanner.stop()  
  
asyncio.run(main())

STEPPED_ON_HEX = "00000000000024000000000000"  

def detection_callback(device, advertisement_data):  
   if device.address.upper() != TARGET_MAC:  
       return  
  
   mfg = advertisement_data.manufacturer_data  
   if not mfg:  
       return  
  
   for company_id, data in mfg.items():  
       hex_data = data.hex()  
       if hex_data == STEPPED_ON_HEX:  
           print("[+] Scale has been stepped on")  
           continue  
  
       print(f"Company ID: {company_id}")  
       print(f"Hex Data: {data.hex()}")  

weight_raw = int.from_bytes(data[0:2], byteorder="big")   # 0x1be4 -> 7140

def get_weight_from_bytes(data: bytes) -> tuple[float, float]:
	weight_raw = int.from_bytes(data, byteorder="big")
	weight_kg = weight_raw / 100.0
	weight_lb = weight_kg * 2.2046226218
	return weight_kg, weight_lb

def detection_callback(device, advertisement_data):
	if device.address.upper() != TARGET_MAC:
		return

	mfg = advertisement_data.manufacturer_data
	if not mfg:
		return

	for _, data in mfg.items():
		hex_data = data.hex()
		if hex_data == STEPPED_ON_HEX:
			print("[+] Scale has been stepped on")
			continue

		kg, lb = get_weight_from_bytes(data[0:2])
		print(f"[+] User weighed in at {kg}kgs {lb}lbs")

    async def discover_scale(self, timeout: float = 10.0) -> str:
        """
        Scan using a callback until we see STEPPED_ON_HEX in manufacturer_data.
        Returns the MAC address of that device.
        """
        found = asyncio.Future()
        
                # Bleak scanner callback
        def cb(device, advertisement_data):
            # manufacturer_data is on advertisement_data (stable across Bleak versions)
            mfg = advertisement_data.manufacturer_data or {}
            for _, payload in mfg.items():
                if payload.hex() == STEPPED_ON_HEX and not found.done():
                    found.set_result(device.address)

        try:
            scanner = BleakScanner(cb)
        except BleakBluetoothNotAvailableError:
            exit("[-] Failed to find bluetooth adapter :(")

                # Function to fetch mac address from found list
        async def get_mac_address() -> str | None:
            try:
                await scanner.start()
                try:
                    return await asyncio.wait_for(found, timeout=timeout)
                except asyncio.TimeoutError:
                    return None
            finally:
                await scanner.stop()
                
                # DISCOVERY LOOP HAPPENS HERE!
        while True:
            try:
                mac_address = await get_mac_address()
                if not mac_address:
                    continue
                print(f"[+] Found scale with MAC Address: {mac_address}")
                return mac_address
            except (KeyboardInterrupt, asyncio.CancelledError):
                exit("[-] CTRL+C detected!")