package io.oxygenhub.android.alerts

import android.app.Notification

import android.app.NotificationChannel

import android.app.NotificationManager

import android.app.PendingIntent

import android.app.job.JobInfo

import android.app.job.JobScheduler

import android.content.ComponentName

import android.content.Context

import android.content.Intent

import androidx.core.content.edit

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.R

import io.oxygenhub.android.api.ProposalBrief

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

/**

 * Notifications when a proposal can be landed (#20): every 15 minutes the

 * phone asks the hub what the account can land now (oxygenhub#311) and

 * says which proposals have become landable since it last asked. Polling

 * until FCM (#16) can push the same.

 */

object LandAlerts {

    private const val PREFS = "alerts"

    private const val ON = "land.on"

    private const val SEEN = "land.seen"

    private const val JOB = 20

    private const val CHANNEL = "landable"

    private const val EVERY_MS = 15 * 60 * 1000L

    /** Extras on the intent a notification opens: the proposal to show. */

    const val EXTRA_REPOSITORY = "io.oxygenhub.android.proposal.repository"

    const val EXTRA_NUMBER = "io.oxygenhub.android.proposal.number"

    private val _on = MutableStateFlow<Boolean?>(null)

    /** Whether the alerts are on, once [refresh] has read it. */

    val on: StateFlow<Boolean?> = _on.asStateFlow()

    fun refresh(context: Context) {

        _on.value = prefs(context).getBoolean(ON, false)

    }

    /**

     * Turn the alerts on: the check runs every 15 minutes on any network,

     * across reboots. What is landable already is said at the first check.

     */

    fun enable(context: Context) {

        prefs(context).edit {

            putBoolean(ON, true)

            remove(SEEN)

        }

        val job = JobInfo.Builder(JOB, ComponentName(context, LandCheckJob::class.java))

            .setPeriodic(EVERY_MS)

            .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)

            .setPersisted(true)

            .build()

        context.getSystemService(JobScheduler::class.java)?.schedule(job)

        _on.value = true

    }

    fun disable(context: Context) {

        context.getSystemService(JobScheduler::class.java)?.cancel(JOB)

        prefs(context).edit {

            putBoolean(ON, false)

            remove(SEEN)

        }

        _on.value = false

    }

    /** The proposals to say now, and what to remember for the next check. */

    fun fresh(seen: Set<String>, landable: List<ProposalBrief>): Pair<List<ProposalBrief>, Set<String>> {

        val now = landable.associateBy(::key)

        // Only what is landable now is remembered, so one that stops being

        // landable and becomes so again is said again.

        return now.filterKeys { it !in seen }.values.toList() to now.keys

    }

    /** Say what has become landable since the last check, and remember what is landable now. */

    fun check(context: Context, landable: List<ProposalBrief>) {

        val prefs = prefs(context)

        if (!prefs.getBoolean(ON, false)) return

        val (say, keep) = fresh(prefs.getStringSet(SEEN, emptySet()).orEmpty(), landable)

        say.forEach { notify(context, it) }

        prefs.edit { putStringSet(SEEN, keep) }

    }

    private fun key(p: ProposalBrief) = "${p.repository}#${p.number}"

    private fun notify(context: Context, p: ProposalBrief) {

        val manager = context.getSystemService(NotificationManager::class.java) ?: return

        manager.createNotificationChannel(

            NotificationChannel(CHANNEL, "Ready to land", NotificationManager.IMPORTANCE_DEFAULT).apply {

                description = "A proposal you can land: its checks and reviews are settled"

            },

        )

        val open = Intent(context, MainActivity::class.java)

            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)

            .putExtra(EXTRA_REPOSITORY, p.repository)

            .putExtra(EXTRA_NUMBER, p.number)

        val id = key(p).hashCode()

        val tap = PendingIntent.getActivity(context, id, open, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)

        val notification = Notification.Builder(context, CHANNEL)

            .setSmallIcon(R.drawable.ic_launcher_monochrome)

            .setContentTitle("Ready to land: ${p.repository}#${p.number}")

            .setContentText(p.title)

            .setStyle(Notification.BigTextStyle().bigText("${p.title}\nby ${p.author}"))

            .setContentIntent(tap)

            .setAutoCancel(true)

            .build()

        manager.notify(id, notification)

    }

    private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)

}