package io.oxygenhub.android.widget

import android.content.Context

import android.content.res.Configuration

import androidx.compose.runtime.Composable

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.unit.dp

import androidx.compose.ui.unit.sp

import androidx.glance.GlanceId

import androidx.glance.GlanceModifier

import androidx.glance.Image

import androidx.glance.ImageProvider

import androidx.glance.LocalContext

import androidx.glance.LocalSize

import androidx.glance.GlanceTheme

import androidx.glance.action.actionStartActivity

import androidx.glance.action.clickable

import androidx.glance.appwidget.GlanceAppWidget

import androidx.glance.appwidget.GlanceAppWidgetReceiver

import androidx.glance.appwidget.SizeMode

import androidx.glance.appwidget.cornerRadius

import androidx.glance.appwidget.provideContent

import androidx.glance.background

import androidx.glance.color.ColorProvider

import androidx.glance.layout.Alignment

import androidx.glance.layout.Box

import androidx.glance.layout.Column

import androidx.glance.layout.ContentScale

import androidx.glance.layout.Row

import androidx.glance.layout.Spacer

import androidx.glance.layout.fillMaxSize

import androidx.glance.layout.fillMaxWidth

import androidx.glance.layout.height

import androidx.glance.layout.padding

import androidx.glance.layout.size

import androidx.glance.layout.width

import androidx.glance.material3.ColorProviders

import androidx.glance.text.FontWeight

import androidx.glance.text.Text

import androidx.glance.text.TextStyle

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.OxygenHubApp

import io.oxygenhub.android.R

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.UserSky

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

import io.oxygenhub.android.ui.theme.DarkColorScheme

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.LightColorScheme

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

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

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.async

import kotlinx.coroutines.coroutineScope

/** What the widget shows (#28); `signedIn` false asks for a sign-in instead. */

data class WidgetData(

    val signedIn: Boolean,

    val runs: List<UserFlowRun> = emptyList(),

    val unread: Long? = null,

    val reviews: Int? = null,

    /** Your sky, drawn behind the content; null keeps the plain surface. */

    val sky: UserSky? = null,

) {

    companion object {

        /** Each part on its own: one the hub cannot give is left out, not the whole widget. */

        suspend fun load(api: HubApi?): WidgetData = coroutineScope {

            if (api == null) return@coroutineScope WidgetData(signedIn = false)

            suspend fun <T> quietly(f: suspend () -> T): T? = try {

                f()

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                null

            }

            val runs = async { quietly { api.userFlowRuns() } }

            val unread = async { quietly { api.inbox(limit = 1).unread } }

            val reviews = async { quietly { api.userProposals().review.size } }

            val sky = async { quietly { api.userSky() } }

            WidgetData(true, runs.await().orEmpty().take(MAX_RUNS), unread.await(), reviews.await(), sky.await())

        }

        const val MAX_RUNS = 3

    }

}

/**

 * A home screen widget (#28): your latest runs, unread notifications and

 * reviews waiting; a tap opens the app. The OxygenHub mark heads it and Your

 * sky is drawn behind it, at the widget's own size (#30).

 */

class HubWidget : GlanceAppWidget() {

    /** Composed for each size the launcher shows it at, so the sky fits exactly. */

    override val sizeMode: SizeMode = SizeMode.Exact

    override suspend fun provideGlance(context: Context, id: GlanceId) {

        val api = (context.applicationContext as OxygenHubApp).container.sessions.api()

        val data = WidgetData.load(api)

        provideContent {

            GlanceTheme(colors = ColorProviders(light = LightColorScheme, dark = DarkColorScheme)) { Content(data) }

        }

    }

}

class HubWidgetReceiver : GlanceAppWidgetReceiver() {

    override val glanceAppWidget: GlanceAppWidget = HubWidget()

}

private val ok = ColorProvider(LightOk, DarkOk)

private val bad = ColorProvider(LightBad, DarkBad)

private val warn = ColorProvider(LightWarn, DarkWarn)

@Composable

private fun Content(d: WidgetData) {

    val title = TextStyle(color = GlanceTheme.colors.primary, fontSize = 15.sp, fontWeight = FontWeight.Bold)

    val body = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 13.sp)

    val mute = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 12.sp)

    val context = LocalContext.current

    val size = LocalSize.current

    val dark = (context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

    val density = context.resources.displayMetrics.density

    val sky = if (d.signedIn) skyImage(d.sky, size.width.value, size.height.value, density, dark) else null

    Box(GlanceModifier.fillMaxSize().cornerRadius(16.dp).background(GlanceTheme.colors.surfaceVariant).clickable(actionStartActivity<MainActivity>())) {

        if (sky != null) {

            Image(sky, contentDescription = null, contentScale = ContentScale.Crop, modifier = GlanceModifier.fillMaxSize())

            // Text stays readable over the marks.

            Box(GlanceModifier.fillMaxSize().background(scrim)) {}

        }

        Column(GlanceModifier.fillMaxSize().padding(12.dp)) { Body(d, title, body, mute) }

    }

}

/** The widget's sky as an image, or null when there is nothing to draw or drawing fails (the plain surface stays). */

private fun skyImage(sky: UserSky?, widthDp: Float, heightDp: Float, density: Float, dark: Boolean): ImageProvider? = try {

    SkyBitmap.frame(sky, widthDp, heightDp, dark)?.let {

        ImageProvider(SkyBitmap.render(it, (widthDp * density).toInt().coerceAtLeast(1), (heightDp * density).toInt().coerceAtLeast(1), density, dark))

    }

} catch (_: Throwable) {

    // A missing native library, or a launcher's odd size: the widget is worth more than its backdrop.

    null

}

private val scrim = ColorProvider(LightColorScheme.surfaceVariant.copy(alpha = 0.55f), DarkColorScheme.surfaceVariant.copy(alpha = 0.5f))

@Composable

private fun Body(d: WidgetData, title: TextStyle, body: TextStyle, mute: TextStyle) {

    Column {

        Row(verticalAlignment = Alignment.CenterVertically) {

            Image(ImageProvider(R.drawable.mark), contentDescription = null, modifier = GlanceModifier.size(width = 28.dp, height = 14.dp))

            Spacer(GlanceModifier.width(6.dp))

            Text("OxygenHub", style = title)

        }

        Spacer(GlanceModifier.height(6.dp))

        if (!d.signedIn) {

            Text("Sign in to see your runs, inbox and reviews.", style = mute)

            return@Column

        }

        if (d.runs.isEmpty()) Text("No runs yet.", style = mute)

        d.runs.forEach { r ->

            Row(GlanceModifier.fillMaxWidth().padding(vertical = 2.dp), verticalAlignment = Alignment.CenterVertically) {

                Box(GlanceModifier.size(10.dp).cornerRadius(5.dp).background(colourOf(r.run.status))) {}

                Spacer(GlanceModifier.width(8.dp))

                Text("${r.repository} #${r.run.number}", style = body, maxLines = 1, modifier = GlanceModifier.defaultWeight())

                Text(r.run.status, style = mute)

            }

        }

        Spacer(GlanceModifier.height(6.dp))

        Row {

            d.unread?.let { Text(if (it == 0L) "Inbox clear" else "$it unread", style = mute) }

            if (d.unread != null && d.reviews != null) Text("  ·  ", style = mute)

            d.reviews?.let { Text(if (it == 0) "no reviews waiting" else "$it to review", style = mute) }

        }

    }

}

private fun colourOf(status: String) = when (status) {

    "passed" -> ok

    "failed", "error" -> bad

    "running", "queued" -> warn

    else -> ColorProvider(Color.Gray, Color.Gray)

}