@Composable
fun Capture(
    key: Int = currentCompositeKeyHash,
    context: Context = LocalContext.current,
    transformation: Transformation = NoTransformation,
    content: @Composable () -> Unit,
    onBitmapCaptured: (Bitmap) -> Unit,
) {
    val cachedBitmap = BitmapCache[key]

    if (cachedBitmap != null) {
        onBitmapCaptured(cachedBitmap)
        return
    }

    val scope = rememberCoroutineScope()

    val view = remember(key) {
        ComposeView(context).apply { visibility = INVISIBLE }
    }

    LaunchedEffect(view) {
        <http://view.post|view.post> {
            scope.launch {
                val bitmap = withContext(Default) {
                    view.createTransformedBitmap(transformation)
                }

                BitmapCache[key] = bitmap
                onBitmapCaptured(bitmap)
            }
        }
    }

    AndroidView(
        factory = {
            view.apply { setContent(content) }
        },
    )
}

var script: RenderScript? = null
var input: Allocation? = null
var output: Allocation? = null
var blur: ScriptIntrinsicBlur? = null
try {
    script = RenderScript.create(context)
    script.messageHandler = RSMessageHandler()

    input = createFromBitmap(
        script,
        bitmap,
        MIPMAP_NONE,
        USAGE_SCRIPT,
    )

    output = createTyped(
        script,
        input.type,
    )

    blur = create(
        script,
        U8_4(script),
    )

    blur.setInput(input)
    blur.setRadius(radius)
    blur.forEach(output)
    output.copyTo(bitmap)
} finally {
    script?.destroy()
    input?.destroy()
    output?.destroy()
    blur?.destroy()
}
return bitmap

@Composable
fun Capture(
    key: Int = currentCompositeKeyHash,
    transformation: Transformation = NoTransformation,
    content: @Composable () -> Unit,
    callback: (Bitmap) -> Unit,
) {
    val cachedBitmap = BitmapCache[key]

    if (cachedBitmap != null) {
        callback(cachedBitmap)
        return
    }

    val scope = rememberCoroutineScope()

    AndroidView(
        factory = { context ->
            ComposeView(context).apply {
                visibility = INVISIBLE

                captureBitmap(
                    scope = scope,
                    transformation = transformation,
                    content = content,
                    callback = { bitmap ->
                        BitmapCache[key] = bitmap
                        callback(bitmap)
                    },
                )
            }
        },
    )
}

private inline fun ComposeView.captureBitmap(
    scope: CoroutineScope,
    transformation: Transformation,
    noinline content: @Composable () -> Unit,
    crossinline callback: (Bitmap) -> Unit,
) {
    setContent(content)

    val listener = object : OnGlobalLayoutListener {
        override fun onGlobalLayout() {
            viewTreeObserver.removeOnGlobalLayoutListener(this)

            scope.launch {
                val bitmap = withContext(Default) {
                    createTransformedBitmap(transformation)
                }

                callback(bitmap)
            }
        }
    }

    viewTreeObserver.addOnGlobalLayoutListener(listener)
}

private suspend fun View.createTransformedBitmap(
    transformation: Transformation,
): Bitmap {
    val bitmap = createBitmap(
        width,
        height,
        ARGB_8888,
    )

    val canvas = Canvas(bitmap)
    draw(canvas)

    return transformation.transform(
        context = context,
        bitmap = bitmap,
    )
}