val environment = NativeAndroidEnvironment.getInstance(context, isNeverForLocationFlagSet = true)

val environment = MockAndroidEnvironment.Api31(
    // Customize the mock environment using various flags:
    isNeverForLocationFlagSet = false,
    isBluetoothScanPermissionGranted = false,
    isBluetoothConnectPermissionGranted = false,
    isBluetoothAdvertisePermissionGranted = false,
    // ... and many more.
)

@Module
@InstallIn(ActivityRetainedComponent::class)
object EnvironmentModule {

    @ActivityRetainedScoped
    @Provides
    fun provideEnvironment(
        @ApplicationContext context: Context,
        lifecycle: ActivityRetainedLifecycle,
    ): NativeAndroidEnvironment {
        // Make sure the environment is closed when the lifecycle is cleared.
        // This will unregister the broadcast receiver.
        return NativeAndroidEnvironment.getInstance(context, true)
            .also { lifecycle.addOnClearedListener { it.close() } }
    }
}

val centralManager = CentralManager.Factory.native(environment, scope)

private val hrm = PeripheralSpec
    .simulatePeripheral(
        identifier = "11:22:33:44:55:66",
        proximity = Proximity.FAR,
    ) {
        advertising(
            parameters = LegacyAdvertisingSetParameters(
                connectable = true,
                interval = 500.milliseconds,
                txPowerLevel = -7,
            ),
        ) {
            ServiceUuid(shortUuid = 0x180D) // Heart Rate Service
            CompleteLocalName("Nordic HRM")
        }
    }

val centralManager = CentralManager.mock(environment, scope)
    .apply {
        simulatePeripherals(listOf(hrm /*, ... */))
    }

centralManager
    .scan(1250.milliseconds) {
        ServiceUUID(someServiceUUID)
        Any {
            Name("MyName")
            Name("OtherName")
        }
    }
    .distinctByPeripheral()
    .map {
        it.peripheral
    }
    .onEach { peripheral ->
        // Do something with the peripheral
    }
    .launchIn(scope)

scope.launch {
    try {
        withTimeout(10000) {
            centralManager.connect(
                peripheral = peripheral,
                options = CentralManager.ConnectionOptions.Direct(
                    timeout = 3.seconds,
                    retry = 2,
                    retryDelay = 1.seconds,
                    Phy.PHY_LE_1M,
                ),
                // options = CentralManager.ConnectionOptions.AutoConnect,
            )
            Timber.i("Connected to ${peripheral.name}!")
        }
    
        // The first time the app connects to the peripheral it needs to initiate
        // observers for various parameters.
        // The observers will get cancelled when the connection scope gets cancelled,
        // that is when the device is manually disconnected in case of auto connect,
        // or disconnects for any reason when auto connect was false.
        peripheral.phy
            .onEach {
                Timber.i("PHY changed to: $it")
            }
            .onEmpty {
                Timber.w("PHY didn't change")
            }
            .onCompletion {
                Timber.d("PHY collection completed")
            }
            .launchIn(this)
    } catch (e: Exception) {
        Timber.e(e, "Connection attempt failed")
    }
}

peripheral.services()
    .onEach { services ->
        Timber.i("Services changed: $services")

        services.forEach { remoteService ->
            // Do something with the service. See GATT operations below.
        }
    }
    .onEmpty {
        Timber.w("No services found")
    }
    .onCompletion {
        Timber.d("Service collection completed")
    }
    .launchIn(scope)

peripheral.requestHighestValueLength()

val options = CentralManager.ConnectionOptions.Direct(
    timeout = 3.seconds,
    retry = 2,
    retryDelay = 1.seconds,
    automaticallyRequestHighestMtu = true
)
centralManager.connect(
    peripheral = peripheral,
    options = options
)
Timber.i("Connected to ${peripheral.name}!")

val length = peripheral.maximumWriteValueLength(WriteType.WITHOUT_RESPONSE)
Timber.i("Maximum write length for $writeType: $length bytes")

val ledCharacteristic = remoteService.characteristics.firstOrNull { it.uuid == ledCharacteristicUuid }
Timber.i("($ce) Turning LED on...")
ledCharacteristic?.write(byteArrayOf(0x01))

val veryLongData = byteArrayOf(1, 2, 3, 4, 5 /* ... */)
val length = peripheral.maximumWriteValueLength(WriteType.WITHOUT_RESPONSE)
veryLongData.chunked(length).forEach {
    // Writing data one chunk after another:
    characteristic.write(it)
}

// Registering for a notification:
Timber.i("($ce) Awaiting for button press to start LED blinking...")
val result = buttonCharacteristic?.waitForValueChange {
    // Sending command that will trigger a notification:
    Timber.i("($ce) Turning LED on...")
    ledCharacteristic?.write(byteArrayOf(0x01))
}
Timber.i("($ce) Button change to 0x${result?.toHexString()}")

remoteService.characteristics.forEach { remoteCharacteristic ->
    try {
        Timber.w("Reading value of ${remoteCharacteristic.uuid}...")
        val value = remoteCharacteristic.read()
        Timber.i("Value of ${remoteCharacteristic.uuid}: 0x${value.toHexString()}")
    } catch (e: Exception) {
        // An exception is thrown when a characteristic is not readable, or an error occurs.
        Timber.e("Failed to read ${remoteCharacteristic.uuid}: ${e.message}")
    }
}

remoteService.characteristics.forEach { remoteCharacteristic ->
    try {
        Timber.w("Subscribing to ${remoteCharacteristic.uuid}...")
        remoteCharacteristic.subscribe()
            .onEach { newValue ->
                Timber.i("Value of ${remoteCharacteristic.uuid} changed: 0x${newValue.toHexString()}")
            }
            .onEmpty {
                Timber.w("No updates from ${remoteCharacteristic.uuid}")
            }
            .onCompletion {
                Timber.d("Stopped observing updates from ${remoteCharacteristic.uuid}")
            }
            .launchIn(scope)
    } catch (e: Exception) {
        // An exception is thrown when a characteristic does not have NOTIFY or INDICATE property,
        // has no Client Characteristic Configuration descriptor, or an error occurs.
        Timber.e("Failed to subscribe to ${remoteCharacteristic.uuid}: ${e.message}")
    }
}