package io.oxygenhub.android.ui.backdrop

import android.content.Context

import android.os.PowerManager

import android.provider.Settings

import androidx.compose.animation.core.animateFloatAsState

import androidx.compose.animation.core.tween

import androidx.compose.foundation.Canvas

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.BoxScope

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.offset

import androidx.compose.foundation.layout.padding

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Surface

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.DisposableEffect

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableIntStateOf

import androidx.compose.runtime.mutableLongStateOf

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.draw.alpha

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.graphics.Brush

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.graphics.Path

import androidx.compose.ui.graphics.drawscope.DrawScope

import androidx.compose.ui.graphics.drawscope.Stroke

import androidx.compose.ui.graphics.luminance

import androidx.compose.ui.input.pointer.PointerEventPass

import androidx.compose.ui.input.pointer.pointerInput

import androidx.compose.ui.layout.onSizeChanged

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.platform.LocalDensity

import androidx.compose.ui.platform.LocalInspectionMode

import androidx.compose.ui.unit.IntOffset

import androidx.compose.ui.unit.IntSize

import androidx.compose.ui.unit.dp

import io.oxygenhub.android.ui.theme.LocalStatusColors

import java.nio.ByteBuffer

import java.nio.ByteOrder

import kotlin.math.roundToInt

import kotlinx.coroutines.isActive

import uniffi.rust_core.Backdrop as Scene

import uniffi.rust_core.BackdropLabel

/**

 * The website's living backgrounds (#23, the hub's docs/backgrounds.md):

 * one of the hub's own scenes, stepped in rust-core and drawn here as its

 * WebGL draws them in a browser, behind [content]. A finger is its cursor:

 * the touches pass through to the content and the scene sees them too.

 *

 * As on the web, drawing halves its rate 3 s after the last touch and stops

 * after 2 minutes, until the next; it holds still when the system's

 * animations are off or battery saver is on.

 */

@Composable

fun Backdrop(

    key: Any?,

    make: (still: Boolean) -> Scene,

    modifier: Modifier = Modifier,

    content: @Composable BoxScope.() -> Unit,

) {

    // Previews and screenshot tests have no Rust core to step a scene with.

    if (LocalInspectionMode.current) {

        Box(modifier) { content() }

        return

    }

    val context = LocalContext.current

    val still = remember(context) { backdropStill(context) }

    val scene = remember(key, still) { make(still) }

    DisposableEffect(scene) { onDispose { scene.close() } }

    val colours = backdropColours()

    val dark = MaterialTheme.colorScheme.background.luminance() < 0.5f

    val density = LocalDensity.current.density

    var size by remember { mutableStateOf(IntSize.Zero) }

    var frame by remember(scene) { mutableStateOf(Frame.EMPTY) }

    var label by remember(scene) { mutableStateOf<BackdropLabel?>(null) }

    var touchedAt by remember(scene) { mutableLongStateOf(System.nanoTime()) }

    var running by remember(scene) { mutableStateOf(false) }

    var wake by remember(scene) { mutableIntStateOf(0) }

    LaunchedEffect(scene, colours) { scene.colours(colours) }

    LaunchedEffect(scene, size, colours, wake) {

        if (size == IntSize.Zero) return@LaunchedEffect

        scene.resize(size.width / density, size.height / density)

        running = true

        var last = -1L

        var n = 0

        while (isActive) {

            val more = androidx.compose.runtime.withFrameNanos { t ->

                val idle = (System.nanoTime() - touchedAt) / 1e9

                n++

                if (!still && idle > HALF_RATE_AFTER_S && n % 2 == 1) return@withFrameNanos true

                val dt = if (last < 0) 0f else ((t - last) / 1e9).toFloat()

                last = t

                val busy = scene.step(dt)

                frame = Frame.of(scene.frame())

                label = scene.label()

                if (still) busy else idle < STOP_AFTER_S || busy

            }

            if (!more) break

        }

        running = false

    }

    Box(

        modifier

            .onSizeChanged { size = it }

            .pointerInput(scene) {

                awaitPointerEventScope {

                    while (true) {

                        // Seen on the way down, never consumed: the content scrolls and taps as before.

                        val e = awaitPointerEvent(PointerEventPass.Initial)

                        val p = e.changes.firstOrNull() ?: continue

                        scene.point(p.position.x / density, p.position.y / density, p.pressed)

                        touchedAt = System.nanoTime()

                        if (!running) wake++

                    }

                }

            },

    ) {

        Canvas(Modifier.fillMaxSize()) { draw(frame, density, dark) }

        Label(label, density)

        content()

    }

}

/** The name a resting finger shows, centred above the cluster, fading in and out (the web's `.backdrop-label`). */

@Composable

private fun Label(label: BackdropLabel?, density: Float) {

    // The last name stays while it fades out.

    val held = remember { arrayOfNulls<BackdropLabel>(1) }

    if (label != null) held[0] = label

    val alpha by animateFloatAsState(if (label != null) 1f else 0f, tween(220), label = "label")

    val l = held[0] ?: return

    var box by remember { mutableStateOf(IntSize.Zero) }

    Surface(

        shape = MaterialTheme.shapes.small,

        color = MaterialTheme.colorScheme.surface.copy(alpha = 0.85f),

        tonalElevation = 2.dp,

        modifier = Modifier

            .offset { IntOffset((l.x * density - box.width / 2f).roundToInt(), (l.y * density - box.height - 8 * density).roundToInt()) }

            .onSizeChanged { box = it }

            .alpha(alpha),

    ) {

        Text(l.text, style = MaterialTheme.typography.labelMedium, modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp))

    }

}

/** A frame's floats: marks 8 each (x, y, size, shape, premultiplied rgba), links 12 each (two ends of x, y, rgba). */

internal class Frame(val marks: FloatArray, val links: FloatArray) {

    companion object {

        val EMPTY = Frame(FloatArray(0), FloatArray(0))

        fun of(f: uniffi.rust_core.BackdropFrame) = Frame(floats(f.marks), floats(f.links))

        fun floats(b: ByteArray): FloatArray {

            val out = FloatArray(b.size / 4)

            ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer().get(out)

            return out

        }

    }

}

/** A premultiplied colour back to a straight one. */

internal fun straight(r: Float, g: Float, b: Float, a: Float): Color =

    if (a <= 0f) Color.Transparent else Color((r / a).coerceIn(0f, 1f), (g / a).coerceIn(0f, 1f), (b / a).coerceIn(0f, 1f), a.coerceIn(0f, 1f))

private val path = Path()

private fun DrawScope.draw(f: Frame, density: Float, dark: Boolean) {

    val l = f.links

    var i = 0

    while (i + 12 <= l.size) {

        val a = Offset(l[i] * density, l[i + 1] * density)

        val b = Offset(l[i + 6] * density, l[i + 7] * density)

        val ca = straight(l[i + 2], l[i + 3], l[i + 4], l[i + 5])

        val cb = straight(l[i + 8], l[i + 9], l[i + 10], l[i + 11])

        drawLine(Brush.linearGradient(listOf(ca, cb), a, b), a, b, strokeWidth = density)

        i += 12

    }

    val m = f.marks

    i = 0

    while (i + 8 <= m.size) {

        val c = Offset(m[i] * density, m[i + 1] * density)

        val s = m[i + 2] * density

        val colour = straight(m[i + 4], m[i + 5], m[i + 6], m[i + 7])

        // On a dark page a lit mark glows a little, as the web's do on a bright screen.

        if (dark && colour.alpha > 0.5f) drawCircle(colour.copy(alpha = colour.alpha * 0.14f), s * 2.6f, c)

        mark(c, s, m[i + 3].roundToInt(), colour)

        i += 8

    }

}

/** One mark, as the hub's fragment shader draws it (crates/backdrop/src/gl.rs). */

private fun DrawScope.mark(c: Offset, s: Float, shape: Int, colour: Color) {

    when (shape) {

        0 -> drawCircle(colour, s, c) // a push: a dot

        1 -> polygon(c, colour, floatArrayOf(1f, 0f, 0f, 1f, -1f, 0f, 0f, -1f), s / 0.85f) // a proposal: a diamond

        2 -> drawCircle(colour, s * 0.72f, c, style = Stroke(s * 0.56f)) // an issue: a ring

        3 -> polygon(c, colour, STAR, s) // a release: a star

        4 -> drawCircle(colour, s * 0.85f, c, style = Stroke(s * 0.24f)) // a repository: a thin ring

        else -> { // a Flow run: a square

            val h = s / 1.15f

            drawRect(colour, Offset(c.x - h, c.y - h), androidx.compose.ui.geometry.Size(2 * h, 2 * h))

        }

    }

}

/** The shader's four-pointed star: two thin diamonds crossed, meeting at 1/4.5. */

private val STAR = (1f / 4.5f).let { k -> floatArrayOf(1f, 0f, k, k, 0f, 1f, -k, k, -1f, 0f, -k, -k, 0f, -1f, k, -k) }

private fun DrawScope.polygon(c: Offset, colour: Color, unit: FloatArray, r: Float) {

    path.reset()

    path.moveTo(c.x + unit[0] * r, c.y + unit[1] * r)

    var j = 2

    while (j < unit.size) {

        path.lineTo(c.x + unit[j] * r, c.y + unit[j + 1] * r)

        j += 2

    }

    path.close()

    drawPath(path, colour)

}

/**

 * The scene's colours from the theme, as the hub's CSS gives the web's:

 * `--bd-mark`, `--bd-lit` and `--bd-link`, then ok, warn and bad.

 */

@Composable

private fun backdropColours(): List<Float> {

    val dark = MaterialTheme.colorScheme.background.luminance() < 0.5f

    val s = LocalStatusColors.current

    val (mark, lit, link) = if (dark) {

        Triple(Color(0, 224, 240).copy(alpha = 0.12f), Color(0, 240, 255).copy(alpha = 0.85f), Color(0, 240, 255).copy(alpha = 0.35f))

    } else {

        Triple(Color(95, 106, 129).copy(alpha = 0.18f), Color(0, 100, 224).copy(alpha = 0.7f), Color(0, 100, 224).copy(alpha = 0.25f))

    }

    return remember(dark, s) { listOf(mark, lit, link, s.ok, s.warn, s.bad).flatMap { listOf(it.red, it.green, it.blue, it.alpha) } }

}

/** Still, as the web is under prefers-reduced-motion: the system's animations off, or battery saver on. */

private fun backdropStill(context: Context): Boolean {

    val scale = Settings.Global.getFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)

    val saver = context.getSystemService(PowerManager::class.java)?.isPowerSaveMode == true

    return scale == 0f || saver

}

/** As the hub's engine (crates/backdrop/src/lib.rs): a still finger halves the rate after 3 s; 2 minutes stops it. */

private const val HALF_RATE_AFTER_S = 3.0

private const val STOP_AFTER_S = 120.0