package io.oxygenhub.android.widget

import android.graphics.Bitmap

import android.graphics.Canvas

import android.graphics.LinearGradient

import android.graphics.Paint

import android.graphics.Path

import android.graphics.Shader

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.graphics.toArgb

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.ui.backdrop.Frame

import io.oxygenhub.android.ui.backdrop.STAR

import io.oxygenhub.android.ui.backdrop.skyEvents

import io.oxygenhub.android.ui.backdrop.straight

import io.oxygenhub.android.ui.theme.DarkBad

import io.oxygenhub.android.ui.theme.DarkOk

import io.oxygenhub.android.ui.theme.DarkWarn

import io.oxygenhub.android.ui.theme.LightBad

import io.oxygenhub.android.ui.theme.LightOk

import io.oxygenhub.android.ui.theme.LightWarn

import uniffi.rust_core.Backdrop as Scene

/**

 * Your sky behind the widget: the dashboard's scene, stepped in rust-core

 * until it settles and drawn once into a bitmap at the widget's size. A

 * widget cannot animate, so each refresh draws it anew from the caller's

 * own activity; it is real data, never decoration (the hub's

 * docs/backgrounds.md), and with nothing of the caller's to draw there is no

 * bitmap and the widget keeps its plain surface.

 */

internal object SkyBitmap {

    /** Steps to let a still scene settle; it says when it has. */

    private const val SETTLE_STEPS = 240

    private const val DT = 1f / 30f

    /** Whether there is anything of the caller's to draw. */

    fun drawable(sky: UserSky?): Boolean = sky != null && sky.repos.isNotEmpty() && skyEvents(sky).isNotEmpty()

    /** The scene's colours, as the app's backdrop has them for each theme: mark, lit, link, ok, warn, bad. */

    fun colours(dark: Boolean): List<Float> {

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

            Triple(Color(0, 224, 240).copy(alpha = 0.16f), Color(0, 240, 255).copy(alpha = 0.9f), Color(0, 240, 255).copy(alpha = 0.35f))

        } else {

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

        }

        val status = if (dark) listOf(DarkOk, DarkWarn, DarkBad) else listOf(LightOk, LightWarn, LightBad)

        return (listOf(mark, lit, link) + status).flatMap { listOf(it.red, it.green, it.blue, it.alpha) }

    }

    /** The settled frame of Your sky at [widthDp] × [heightDp], or null when there is nothing to draw. */

    fun frame(sky: UserSky?, widthDp: Float, heightDp: Float, dark: Boolean): Frame? {

        if (!drawable(sky) || widthDp <= 0f || heightDp <= 0f) return null

        val scene = Scene.sky(sky!!.repos, skyEvents(sky), widthDp, heightDp, true)

        return try {

            scene.colours(colours(dark))

            var n = 0

            while (n < SETTLE_STEPS && scene.step(DT)) n++

            Frame.of(scene.frame()).takeIf { it.marks.isNotEmpty() }

        } finally {

            scene.close()

        }

    }

    /** [frame] drawn into a bitmap of [widthPx] × [heightPx] pixels, [density] pixels to the dp. */

    fun render(frame: Frame, widthPx: Int, heightPx: Int, density: Float, dark: Boolean): Bitmap {

        val bitmap = Bitmap.createBitmap(widthPx, heightPx, Bitmap.Config.ARGB_8888)

        draw(Canvas(bitmap), frame, density, dark)

        return bitmap

    }

    private fun draw(canvas: Canvas, f: Frame, density: Float, dark: Boolean) {

        val line = Paint(Paint.ANTI_ALIAS_FLAG).apply { strokeWidth = density; style = Paint.Style.STROKE }

        val l = f.links

        var i = 0

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

            val (ax, ay, bx, by) = listOf(l[i], l[i + 1], l[i + 6], l[i + 7]).map { it * density }

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

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

            line.shader = LinearGradient(ax, ay, bx, by, ca, cb, Shader.TileMode.CLAMP)

            canvas.drawLine(ax, ay, bx, by, line)

            i += 12

        }

        val fill = Paint(Paint.ANTI_ALIAS_FLAG)

        val ring = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }

        val m = f.marks

        i = 0

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

            val (x, y, s) = Triple(m[i] * density, m[i + 1] * density, m[i + 2] * density)

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

            // On a dark widget a lit mark glows a little, as in the app.

            if (dark && colour.alpha > 0.5f) {

                fill.color = colour.copy(alpha = colour.alpha * 0.14f).toArgb()

                canvas.drawCircle(x, y, s * 2.6f, fill)

            }

            fill.color = colour.toArgb()

            ring.color = colour.toArgb()

            when (Math.round(m[i + 3])) {

                0 -> canvas.drawCircle(x, y, s, fill) // a push: a dot

                1 -> canvas.drawPath(polygon(x, y, DIAMOND, s / 0.85f), fill) // a proposal: a diamond

                2 -> canvas.drawCircle(x, y, s * 0.72f, ring.apply { strokeWidth = s * 0.56f }) // an issue: a ring

                3 -> canvas.drawPath(polygon(x, y, STAR, s), fill) // a release: a star

                4 -> canvas.drawCircle(x, y, s * 0.85f, ring.apply { strokeWidth = s * 0.24f }) // a repository: a thin ring

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

                    val h = s / 1.15f

                    canvas.drawRect(x - h, y - h, x + h, y + h, fill)

                }

            }

            i += 8

        }

    }

    private val DIAMOND = floatArrayOf(1f, 0f, 0f, 1f, -1f, 0f, 0f, -1f)

    private fun polygon(x: Float, y: Float, unit: FloatArray, r: Float): Path = Path().apply {

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

        var j = 2

        while (j < unit.size) {

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

            j += 2

        }

        close()

    }

}