import datetime, pytz
import findmy
import findmy.scanner
import findmy.scanner.scanner

import asyncio
import logging
import time

logging.basicConfig(level=logging.INFO)

acc = findmy.accessory.FindMyAccessory.from_plist(open("myairtag.plist", "rb"))
now = datetime.datetime.now(pytz.timezone("EST"))
keys = acc.keys_between(now - datetime.timedelta(hours=24), now + datetime.timedelta(hours=24))



async def scan() -> None:
    scanner = await findmy.scanner.OfflineFindingScanner.create()

    print("Scanning for FindMy-devices...")
    print()

    async for device in scan_for(scanner, 1000, extend_timeout=True):
        print(f"Device - {device.mac_address}")
        print(f"  Public key:   {device.adv_key_b64}")
        print(f"  Lookup key:   {device.hashed_adv_key_b64}")
        print(f"  Status byte:  {device.status:x}")
        print(f"  Hint byte:    {device.hint:x}")
        print("  Extra data:")
        for k, v in sorted(device.additional_data.items()):
            print(f"    {k:20}: {v}")
        print()
        if any((device.adv_key_b64 == k.adv_key_b64) for k in keys):
            print("Found!!!!")
            break

def has_consecutive_four_byte_match(bytes1, bytes2):
    length1 = len(bytes1)
    length2 = len(bytes2)
    
    if length1 < 4 or length2 < 4:
        return False
    
    for i in range(length1 - 3):
        four_bytes1 = bytes1[i:i+4]
        for j in range(length2 - 3):
            four_bytes2 = bytes2[j:j+4]
            if four_bytes1 == four_bytes2:
                return True
                
    return False

async def _wait_for_device(self, timeout: float):
        device, data = await asyncio.wait_for(self._device_fut, timeout=timeout)

        mac_bytes = bytes(int(part, 16) for part in device.address.split(':'))
        for k in keys:
            if has_consecutive_four_byte_match(mac_bytes, k.adv_key_bytes):
                print("Found MAC!!!")
                print(device)
                print(data)
                print(mac_bytes)
                print(k.adv_key_bytes)


        apple_data = data.manufacturer_data.get(self.BLE_COMPANY_APPLE, b"")
        if not apple_data:
            return None

        try:
            additional_data = device.details.get("props", {})
        except AttributeError:
            # Likely Windows host, where details is a '_RawAdvData' object.
            # See: https://github.com/malmeloo/FindMy.py/issues/24
            additional_data = {}
        return  findmy.scanner.scanner.OfflineFindingDevice.from_payload(device.address, apple_data, additional_data)


async def scan_for(
        self,
        timeout: float = 10,
        *,
        extend_timeout: bool = False,
    ):
        """
        Scan for `OfflineFindingDevice`s for up to `timeout` seconds.

        If `extend_timeout` is set, the timer will be extended
        by `timeout` seconds every time a new device is discovered.
        """
        await self._start_scan()

        stop_at = time.time() + timeout
        devices_seen = set()

        try:
            time_left = stop_at - time.time()
            while time_left > 0:
                device = await _wait_for_device(self, time_left)
                if device is not None and device not in devices_seen:
                    devices_seen.add(device)
                    if extend_timeout:
                        stop_at = time.time() + timeout
                    yield device

                time_left = stop_at - time.time()
        except (asyncio.CancelledError, asyncio.TimeoutError):  # timeout reached
            return
        finally:
            await self._stop_scan()

if __name__ == "__main__":
    asyncio.run(scan())