package io.oxygenhub.android.widget

import android.content.Context

import android.content.Intent

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

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

import androidx.glance.action.ActionParameters

import androidx.glance.action.actionParametersOf

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

import io.oxygenhub.android.api.ProposalBrief

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.runner.PhoneRunner

import io.oxygenhub.android.ui.nav.AccountRoute

import io.oxygenhub.android.ui.nav.DashboardRoute

import io.oxygenhub.android.ui.nav.InboxRoute

import io.oxygenhub.android.ui.nav.IssueRoute

import io.oxygenhub.android.ui.nav.ProposalRoute

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,

    /** The one proposal waiting for review, when there is just one: a tap opens it (#31). */

    val onlyReview: ProposalBrief? = null,

    /** Open issues assigned to you (#31); null when the hub cannot say. */

    val assigned: Int? = null,

    /** The one assigned issue, when there is just one: a tap opens it. */

    val onlyAssigned: IssueBrief? = null,

    /** What the phone runs as an OxygenFlow runner while it serves (#31); null when it is not serving. */

    val runnerJobs: List<String>? = null,

    /** The proposal at the head of your reviews, and your newest assigned issue: Needs you (#33). */

    val topReview: ProposalBrief? = null,

    val topAssigned: IssueBrief? = null,

    /** Your last runs' statuses, newest first, for the health strip (#33). */

    val health: List<String> = emptyList(),

) {

    companion object {

        /**

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

         * whole widget. [runnerJobs] is what this phone's runner runs, null

         * when it is not serving.

         */

        suspend fun load(api: HubApi?, runnerJobs: List<String>? = null): 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 } }

            val assigned = async { quietly { api.userIssues() } }

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

            val review = reviews.await()

            val issues = assigned.await()

            val all = runs.await().orEmpty()

            WidgetData(

                signedIn = true,

                runs = all.take(MAX_RUNS),

                unread = unread.await(),

                reviews = review?.size,

                sky = sky.await(),

                onlyReview = review?.singleOrNull(),

                assigned = issues?.size,

                onlyAssigned = issues?.singleOrNull(),

                runnerJobs = runnerJobs,

                topReview = review?.firstOrNull(),

                topAssigned = issues?.firstOrNull(),

                health = all.take(HealthStrip.MAX).map { it.run.status },

            )

        }

        /** What this phone's runner runs, for [load]: null unless it is serving. */

        fun runnerJobs(): List<String>? = when (PhoneRunner.state.value) {

            PhoneRunner.State.Running, is PhoneRunner.State.Draining, is PhoneRunner.State.Leaving -> PhoneRunner.jobs.value

            else -> null

        }

        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); a row of counts

 * and the phone's runner job runs along its foot (#31).

 */

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, WidgetData.runnerJobs())

        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)

/**

 * Where a tap on the widget's counts goes (#31): the extras it puts on the

 * app's intent, and the screen they name.

 */

object WidgetTaps {

    const val OPEN = "io.oxygenhub.android.widget.open"

    const val REPOSITORY = "io.oxygenhub.android.widget.repository"

    const val NUMBER = "io.oxygenhub.android.widget.number"

    /** The screen an intent's extras name, or null for none (the app opens as it would). */

    fun route(open: String?, repository: String?, number: Long): Any? {

        val owner = repository?.substringBefore('/', "")?.takeIf { it.isNotEmpty() }

        val name = repository?.substringAfter('/', "")?.takeIf { it.isNotEmpty() }

        return when (open) {

            "inbox" -> InboxRoute

            "dashboard" -> DashboardRoute

            "account" -> AccountRoute

            "proposal" -> if (owner != null && name != null && number > 0) ProposalRoute(owner, name, number) else DashboardRoute

            "issue" -> if (owner != null && name != null && number > 0) IssueRoute(owner, name, number) else DashboardRoute

            else -> null

        }

    }

    fun route(intent: Intent?): Any? =

        intent?.let { route(it.getStringExtra(OPEN), it.getStringExtra(REPOSITORY), it.getLongExtra(NUMBER, 0)) }

    internal fun action(open: String, repository: String? = null, number: Long = 0) = actionStartActivity<MainActivity>(

        actionParametersOf(

            ActionParameters.Key<String>(OPEN) to open,

            ActionParameters.Key<String>(REPOSITORY) to (repository ?: ""),

            ActionParameters.Key<Long>(NUMBER) to number,

        ),

    )

}

/** The title: white on the dark widget, the text colour on the light one (#31); the mark keeps its own colours (#33). */

private val headline = ColorProvider(LightColorScheme.onSurface, Color.White)

@Composable

private fun Content(d: WidgetData) {

    val title = TextStyle(color = headline, 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(GlanceModifier.fillMaxSize()) {

        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)

            }

        }

        NeedsYou(d, body)

        Spacer(GlanceModifier.defaultWeight())

        Health(d, mute)

        Spacer(GlanceModifier.height(6.dp))

        Counts(d)

    }

}

/**

 * The row along the bottom (#31): unread messages, proposals to review and

 * issues assigned, each an icon and its number (dimmed at zero, left out

 * when the hub cannot say), then what the phone runs while it serves as a

 * runner. Each opens its screen in the app.

 */

@Composable

private fun Counts(d: WidgetData) {

    Row(GlanceModifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {

        d.unread?.let { Count(R.drawable.widget_inbox, "unread", it, WidgetTaps.action("inbox")) }

        d.reviews?.let { n ->

            val r = d.onlyReview

            Count(R.drawable.widget_proposal, "to review", n.toLong(), if (r != null) WidgetTaps.action("proposal", r.repository, r.number) else WidgetTaps.action("dashboard"))

        }

        d.assigned?.let { n ->

            val i = d.onlyAssigned

            Count(R.drawable.widget_issue, "assigned", n.toLong(), if (i != null) WidgetTaps.action("issue", i.repository, i.number) else WidgetTaps.action("dashboard"))

        }

        d.runnerJobs?.let { jobs ->

            Row(GlanceModifier.defaultWeight().clickable(WidgetTaps.action("account")), verticalAlignment = Alignment.CenterVertically) {

                Image(ImageProvider(R.drawable.widget_runner), contentDescription = "This phone runs", colorFilter = ColorFilter.tint(ok), modifier = GlanceModifier.size(14.dp))

                Spacer(GlanceModifier.width(4.dp))

                Text(runnerLine(jobs), style = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 12.sp), maxLines = 1)

            }

        }

    }

}

/** Needs you (#33): the top proposal to review and the newest issue assigned, a line each, opening it. */

@Composable

private fun NeedsYou(d: WidgetData, body: TextStyle) {

    val r = d.topReview

    val i = d.topAssigned

    if (r == null && i == null) return

    Spacer(GlanceModifier.height(8.dp))

    Text("Needs you", style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 11.sp, fontWeight = FontWeight.Bold))

    r?.let { NeedLine(R.drawable.widget_proposal, "Review ${it.repository} #${it.number}: ${it.title}", body, WidgetTaps.action("proposal", it.repository, it.number)) }

    i?.let { NeedLine(R.drawable.widget_issue, "${it.repository} #${it.number}: ${it.title}", body, WidgetTaps.action("issue", it.repository, it.number)) }

}

@Composable

private fun NeedLine(icon: Int, text: String, body: TextStyle, open: Action) {

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

        Image(ImageProvider(icon), contentDescription = null, colorFilter = ColorFilter.tint(headline), modifier = GlanceModifier.size(13.dp))

        Spacer(GlanceModifier.width(8.dp))

        Text(text, style = body, maxLines = 1)

    }

}

/** Flow health (#33): a bar per recent run, and how many of the finished ones passed. */

@Composable

private fun Health(d: WidgetData, mute: TextStyle) {

    val summary = HealthStrip.summary(d.health) ?: return

    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 strip = try {

        // The widget's width less its padding, at 10 dp high.

        ImageProvider(HealthStrip.render(d.health, ((size.width.value - 24f) * density).toInt(), (10f * density).toInt(), density, dark))

    } catch (_: Throwable) {

        null

    }

    Column(GlanceModifier.fillMaxWidth().clickable(actionStartActivity<MainActivity>())) {

        strip?.let { Image(it, contentDescription = summary, contentScale = ContentScale.FillBounds, modifier = GlanceModifier.fillMaxWidth().height(10.dp)) }

        Spacer(GlanceModifier.height(3.dp))

        Text(summary, style = mute, maxLines = 1)

    }

}

/** What the runner part of the row says: the job, how many, or that it waits. */

internal fun runnerLine(jobs: List<String>): String = when (jobs.size) {

    0 -> "Waiting for jobs"

    1 -> jobs[0]

    else -> "${jobs.size} jobs"

}

@Composable

private fun Count(icon: Int, what: String, n: Long, open: Action) {

    val colour = if (n == 0L) GlanceTheme.colors.onSurfaceVariant else headline

    Row(GlanceModifier.padding(end = 14.dp).clickable(open), verticalAlignment = Alignment.CenterVertically) {

        Image(ImageProvider(icon), contentDescription = "$n $what", colorFilter = ColorFilter.tint(colour), modifier = GlanceModifier.size(14.dp))

        Spacer(GlanceModifier.width(4.dp))

        Text("$n", style = TextStyle(color = colour, fontSize = 13.sp, fontWeight = FontWeight.Bold))

    }

}

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

    "passed" -> ok

    "failed", "error" -> bad

    "running", "queued" -> warn

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

}