implementation("ch.ubique.kmp:kmpanion:0.0.1")

// Apply a block only if a condition is true, returns this
view.applyIf(isVisible) { alpha = 1f }

// Like applyIf but returns the result of the block
val result = value.runIf(condition) { transform() }

// Safe and unsafe casting
val str = obj.cast<String>()
val str = obj.castOrNull<String>()

// requireNotNull with an optional lazy message
val value = nullableValue.requireNotNull()
val value = nullableValue.requireNotNull { "Must not be null" }

// Logical implication (a implies b)
val valid = isLoggedIn implies { hasPermission }

// Convert to Int (true → 1, false → 0)
val bit = flag.toInt()

val hex: String = byteArray.toHexString()
val hex: String = byte.toHexString()

"Jane Doe".isValidName()         // true (letters + whitespace/dash only)
"user@example.com".isValidMail() // true
"+41 79 123 45 67".isValidPhone() // true
"hello😀".containsSurrogateChars() // true (emoji = surrogate pair)
val s: String? = null
s.isNotNullOrEmpty()             // false (smart-casts to non-null on true)

list.toArrayList()
listOf(1, 2, 3).containsAny(listOf(3, 4)) // true

val map: Map<String, Int> = mapWithNulls.filterNotNullValues()

sb.appendNonNull(nullableString) // no-op if null

val hash: Long = "hello".longHashCode()

// Convert a String to an enum value
val state = "ACTIVE".toEnum<State>()
val state = "UNKNOWN".toEnum<State>(fallback = State.DEFAULT)
val state = "UNKNOWN".toEnumNullable<State>() // null if no match

val result = runSuspendCatching { fetchData() }

val eventFlow = SingleEventFlow<String>()

// emit
eventFlow.emit("hello")
eventFlow.emit() // shorthand when T is Unit

// collect
eventFlow.asFlow().collect { value -> /* handled once */ }

val counter = SavedStateMutableStateFlow(savedStateHandle, "counter", initialValue = 0)
counter.value = 1 // written to both the flow and the SavedStateHandle

val dist: Float = euclideanDistance(aX, aY, bX, bY)

val v1 = SemanticVersion("1.2.3")
val v2 = SemanticVersion("1.10.0")
println(v1 < v2) // true

v1 == SemanticVersion("1.2.3") // true

// Overlay a foreground bitmap onto a copy of the background
val combined: Bitmap? = background.overlaid(foreground)
val combined: Bitmap? = background.overlaid(foreground, matrix, paint)

// Overlay in-place (mutates the background)
background.overlay(foreground)

// Rotate
val rotated: Bitmap = bitmap.rotated(90f)

// Encode to Base64 (suspending)
val base64: String = bitmap.asBase64()

// Optional (returns null if missing)
val parcel: MyParcelable? = bundle.optionalParcelable("key")
val list: ArrayList<MyParcelable>? = bundle.optionalParcelableArrayList("key")
val serial: MySerializable? = bundle.optionalSerializable("key")
val map: Map<String, Int>? = bundle.optionalSerializableMap("key")

// Required (throws if missing)
val parcel: MyParcelable = bundle.requireParcelable("key")
val str: String = bundle.requireString("key")

// Builder DSL
val bundle = buildBundle {
	putString("key", "value")
	putInt("count", 42)
}

val hex: String = byteArray.md5()
val raw: ByteArray = byteArray.md5Bytes()

val hex: String = "hello".md5()
val raw: ByteArray = "hello".md5Bytes()

context.dpToPx(16)    // Float
context.spToPx(14)    // Float

context.isTablet()    // true if smallestScreenWidthDp >= 600
context.isPortrait()
context.isLandscape()

context.getStringByResName("my_string_name")
context.getDrawableByResName("my_drawable_name")

context.isPackageInstalled("com.example.app")
context.isTalkBackEnabled()
context.isInDarkMode()

context.getActivityContext()         // Activity? (walks the ContextWrapper chain)
context.requireActivityContext()     // Activity (throws if not found)

context.isPermissionGranted(Manifest.permission.CAMERA)
context.isLocationServiceEnabled()
context.getLocationPermissionState() // LocationPermissionState enum

cursor.getStringOrNull("name")
cursor.getLongOrNull("timestamp")
cursor.getIntOrNull("count")
cursor.getDoubleOrNull("lat")
cursor.getFloatOrNull("score")
cursor.getShortOrNull("flags")

// Read EXIF rotation from an image file (0 / 90 / 180 / 270)
val degrees: Int = file.getImageRotation()

val dist: Float = point.euclideanDistanceTo(other)
val dist: Float = pointF.euclideanDistanceTo(otherX, otherY)

spannable.replace(Pattern.compile("\\bhello\\b")) { matchResult, matched ->
	SpannableString(matched).apply {
		setSpan(StyleSpan(Typeface.BOLD), 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
	}
}

"café".unaccent()       // "cafe"
"hello world".capitalize() // "Hello world"
"query param".urlEncode()  // "query%20param"

val prefs = context.getSharedPreferences("prefs", Context.MODE_PRIVATE)
val isDarkMode = SharedPreferenceMutableStateFlow(prefs, "dark_mode", initialValue = false)

isDarkMode.value = true // persisted to SharedPreferences immediately

when (context.getLocationPermissionState()) {
	LocationPermissionState.FINE_BACKGROUND -> { /* precise + background */
	}
	LocationPermissionState.FINE_FOREGROUND -> { /* precise, foreground only */
	}
	LocationPermissionState.COARSE_BACKGROUND -> { /* approximate + background */
	}
	LocationPermissionState.COARSE_FOREGROUND -> { /* approximate, foreground only */
	}
	LocationPermissionState.DENIED -> { /* not granted */
	}
}

// In an Activity or Fragment
val handler = registerPermissionHandler(
	Manifest.permission.CAMERA,
	object : RuntimePermissionHandler.Listener {
		override fun onPermissionResult(isGranted: Boolean) { /* react */
		}
		override fun showJumpToAppSettingsExplanation(intent: Intent) {
			// Show a dialog explaining why the user should go to settings, then startActivity(intent)
		}
	}
)

// When the user taps "Grant"
handler.requestPermission()

// Check state
handler.isPermissionGranted()

// Open the correct settings screen directly
handler.openAppSettings()

SinglePaneLayout(
	maxWidth = 640.dp,
	alignment = Alignment.TopCenter,
) {
	MyContent()
}

SinglePaneLazyColumn(
	maxContentWidth = 640.dp,
	alignment = Alignment.CenterHorizontally,
) {
	items(myList) { item -> MyListItem(item) }
}

UbiqueButton(onClick = { /* ... */ }) {
	filled {
		icon(R.drawable.ic_send, size = 20.dp)
		spacing(8.dp)
		text("Send")
	}
}

UbiqueButton(enabled = isLoading.not(), onClick = { /* ... */ }) {
	outlined {
		loading(size = 20.dp)
		spacing(8.dp)
		text("Loading…")
	}
}

UbiqueButton(onClick = { /* ... */ }) {
	icon(R.drawable.ic_close)
}

// Turn a nullable value into an optional @Composable lambda
val content: (@Composable () -> Unit)? = nullableItem.letComposable { item ->
	Text(item.label)
}

val clipboard = LocalClipboard.current

// Write
LaunchedEffect(Unit) { clipboard.setText("Hello") }

// Read
LaunchedEffect(Unit) { val text = clipboard.getText() }

// Shorthand for copy(alpha = …)
val faded = color.alpha(0.5f)

// Pick light/dark-mode color inline
val background = Color.White or Color.Black // second value used in dark mode

LazyColumn {
	// Items with built-in animateItem() modifier
	animatedItem(key = "header") { MyHeader() }
	animatedItems(items = myList, key = { it.id }) { item -> MyRow(item) }

	// Spacer item
	spacer(size = 16.dp)
}

// Return a zero-size layout from a custom Layout measurement
fun MeasureResult = emptyLayout()

MaterialTheme.typography.bodyMedium.bold.italic.underline
MaterialTheme.typography.titleLarge.color(Color.Red)
MaterialTheme.typography.labelSmall.white

Modifier.windowInsetsPadding(WindowInsets.none) // zero insets

Base64Image(
	encodedImage = base64String,
	placeholder = { CircularProgressIndicator() },
	contentScale = ContentScale.Crop,
)

val drawable by rememberBlurHashDrawable(
	blurhash = "LKO2?U%2Tw=w]~RBVZRi};RPxuwH",
	blurhashHeight = 200.dp,
	blurhashAspectRatio = 16.0 / 9.0,
)

LargeBitmapImage(
	bitmapLoader = { BitmapFactory.decodeFile(path) },
	contentScale = ContentScale.Fit,
)

SelectableColumn {
	Text("This text can be selected")
	Text("So can this")
}

// Continuously rotate an element
Icon(painter, modifier = Modifier.infiniteRotation(durationPerRotationInMs = 1000))

// Detect a triple-tap
Box(modifier = Modifier.tripleClick { showEasterEgg() })

// Detect an N-tap
Box(modifier = Modifier.multiClick(count = 5) { doSomething() })

PermissionScaffold(
	permission = Manifest.permission.CAMERA,
	permissionNotGrantedContent = { handler ->
		Button(onClick = handler::requestPermission) { Text("Grant Camera") }
	},
	permissionRationaleContent = { intent, onHandled ->
		AlertDialog(
			onDismissRequest = onHandled,
			confirmButton = { TextButton(onClick = { startActivity(intent); onHandled() }) { Text("Settings") } },
			text = { Text("Camera access is required. Please enable it in Settings.") },
		)
	},
	permissionGrantedContent = {
		CameraPreview()
	},
	onPermissionGranted = { /* one-shot callback */ },
)

@ScreenPreviews
@Composable
fun MyScreenPreview() {
	MyTheme { MyScreen() }
}

ScreenBrightnessOverride()

ScreenshotProtection()

// Default: follows system dark mode
StatusBarColor()

// Or explicitly
StatusBarColor(useLightStatusBarIcons = true)

SwipeableContainer(
	canSwipeToLeft = true,
	onSwipedToLeft = { deleteItem() },
	swipeToLeftContent = {
		Box(Modifier.fillMaxSize().background(Color.Red)) {
			Icon(Icons.Default.Delete, contentDescription = null)
		}
	},
) {
	MyListItem()
}

// Checkbox
Toggleable(
	toggleState = if (isChecked) ToggleableState.On else ToggleableState.Off,
	onClick = { isChecked = !isChecked }
) {
	checkbox(toggleState)
	spacing(10.dp)
	label("Accept terms", MaterialTheme.typography.bodyMedium)
}

// Switch
Toggleable(
	toggleState = isEnabled.toToggleableState(),
	onClick = { isEnabled = !isEnabled }
) {
	label("Enable notifications", MaterialTheme.typography.bodyMedium)
	spacing(10.dp)
	switch(checked = isEnabled)
}

val state: ToggleableState = true.toToggleableState()
val bool: Boolean = ToggleableState.Indeterminate.toBoolean(indeterminateValue = false)

val state = remember { WebViewState(WebContent.Url("https://example.com")) }

UbiqueWebView(
	state = state,
	captureBackPresses = true,
	onCreated = { webView -> webView.settings.javaScriptEnabled = true },
)

// Check loading state
if (state.isLoading) CircularProgressIndicator()