package uk.orllewin.sianel.data

import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.content.pm.ServiceInfo
import android.media.MediaMetadataRetriever
import android.net.Uri
import android.os.Build
import android.os.Handler
import android.os.Looper
import androidx.annotation.OptIn
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.media3.common.MediaItem
import androidx.media3.common.MimeTypes
import androidx.media3.common.util.UnstableApi
import androidx.media3.effect.Presentation
import androidx.media3.transformer.Composition
import androidx.media3.transformer.DefaultEncoderFactory
import androidx.media3.transformer.EditedMediaItem
import androidx.media3.transformer.Effects
import androidx.media3.transformer.ExportException
import androidx.media3.transformer.ExportResult
import androidx.media3.transformer.ProgressHolder
import androidx.media3.transformer.Transformer
import androidx.media3.transformer.VideoEncoderSettings
import androidx.work.CoroutineWorker
import androidx.work.ForegroundInfo
import androidx.work.WorkManager
import androidx.work.WorkerParameters
import androidx.work.workDataOf
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withContext
import java.io.File
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

/**
 * Compresses (optional) then uploads a cached video file. Survives backgrounding
 * because WorkManager re-runs.
 * Progress is reported under [KEY_PROGRESS] and tagged with a [KEY_PHASE] of "compress" or "upload"
 * so the UI can label it.
 */
class UploadWorker(
    appContext: Context,
    params: WorkerParameters,
) : CoroutineWorker(appContext, params) {

    override suspend fun getForegroundInfo(): ForegroundInfo =
        buildForegroundInfo(title = "Preparing video upload", text = null, percent = null)

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        // Promote to a foreground service so big uploads survive backgrounding.
        // setExpedited on the request side means this only kicks in when the OS
        // can't grant expedited quota.
        runCatching { setForeground(getForegroundInfo()) }

        val filePath = inputData.getString(KEY_FILE_PATH)
            ?: return@withContext fail("no file path")
        val mime = inputData.getString(KEY_MIME) ?: "video/mp4"
        val quality = runCatching {
            Quality.valueOf(inputData.getString(KEY_QUALITY) ?: Quality.ORIGINAL.name)
        }.getOrDefault(Quality.ORIGINAL)
        val password = Prefs.getPassword(applicationContext)
        if (password.isBlank()) return@withContext fail("no password set")
        val baseUrl = Prefs.getBaseUrl(applicationContext)

        val source = File(filePath)
        if (!source.exists()) return@withContext fail("file no longer available")

        val thumb = inputData.getString(KEY_THUMB_PATH)
            ?.let { File(it) }
            ?.takeIf { it.exists() }
        val unlisted = inputData.getBoolean(KEY_UNLISTED, false)

        fun cleanup(also: File? = null) {
            source.delete()
            also?.delete()
            thumb?.delete()
        }

        val toUpload = if (quality.transcodes && shouldTranscode(source, quality)) {
            try {
                transcode(source, quality) { p ->
                    setProgressAsync(workDataOf(KEY_PROGRESS to p, KEY_PHASE to PHASE_COMPRESS))
                    updateNotification("Compressing video", (p * 100).toInt())
                }
            } catch (e: Throwable) {
                cleanup()
                return@withContext fail("compress failed: ${e.message}")
            }
        } else source

        return@withContext try {
            val uploadMime = if (toUpload != source) "video/mp4" else mime
            val result = SianelService(password, baseUrl).upload(
                file = toUpload,
                mime = uploadMime,
                thumbnail = thumb,
                thumbnailMime = "image/jpeg",
                unlisted = unlisted,
            ) { p, chunk, total ->
                setProgressAsync(
                    workDataOf(
                        KEY_PROGRESS to p,
                        KEY_PHASE to PHASE_UPLOAD,
                        KEY_CHUNK_INDEX to chunk,
                        KEY_CHUNK_TOTAL to total,
                    )
                )
                val title = if (total > 1) {
                    "Uploading video (chunk $chunk/$total)"
                } else {
                    "Uploading video"
                }
                updateNotification(title, (p * 100).toInt())
            }
            cleanup(also = toUpload.takeIf { it != source })
            Result.success(
                workDataOf(
                    KEY_HASH to result.hash,
                    KEY_URL to result.url,
                    KEY_EMBED to result.embed,
                    KEY_THUMBNAIL_URL to result.thumbnail,
                )
            )
        } catch (e: Throwable) {
            cleanup(also = toUpload.takeIf { it != source })
            fail(e.message ?: e::class.java.simpleName)
        }
    }

    private fun shouldTranscode(source: File, quality: Quality): Boolean {
        val target = quality.targetHeight ?: return false
        val height = probeHeight(source) ?: return true   // can't probe → transcode anyway
        return height > target
    }

    private fun probeHeight(file: File): Int? {
        val r = MediaMetadataRetriever()
        return try {
            r.setDataSource(file.absolutePath)
            r.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull()
        } catch (_: Throwable) {
            null
        } finally {
            runCatching { r.release() }
        }
    }

    @OptIn(UnstableApi::class)
    private suspend fun transcode(
        src: File,
        quality: Quality,
        onProgress: (Float) -> Unit,
    ): File {
        val out = File(applicationContext.cacheDir, "trans-${System.currentTimeMillis()}.mp4")
        val main = Handler(Looper.getMainLooper())
        // Transformer's API must be touched from a single thread (main looper).
        return suspendCancellableCoroutine { cont ->
            main.post {
                val transformer = Transformer.Builder(applicationContext)
                    .setVideoMimeType(MimeTypes.VIDEO_H264)
                    .setEncoderFactory(
                        DefaultEncoderFactory.Builder(applicationContext)
                            .setRequestedVideoEncoderSettings(
                                VideoEncoderSettings.Builder()
                                    .setBitrate(quality.bitrate!!)
                                    .build()
                            )
                            .build()
                    )
                    .addListener(object : Transformer.Listener {
                        override fun onCompleted(c: Composition, r: ExportResult) {
                            if (cont.isActive) cont.resume(out)
                        }
                        override fun onError(c: Composition, r: ExportResult, e: ExportException) {
                            if (cont.isActive) cont.resumeWithException(e)
                        }
                    })
                    .build()

                val item = EditedMediaItem.Builder(MediaItem.fromUri(Uri.fromFile(src)))
                    .setEffects(
                        Effects(
                            emptyList(),
                            listOf(Presentation.createForHeight(quality.targetHeight!!))
                        )
                    )
                    .build()

                transformer.start(item, out.absolutePath)

                val holder = ProgressHolder()
                val poll = object : Runnable {
                    override fun run() {
                        if (!cont.isActive) return
                        when (transformer.getProgress(holder)) {
                            Transformer.PROGRESS_STATE_AVAILABLE -> {
                                onProgress(holder.progress / 100f)
                                main.postDelayed(this, 200)
                            }
                            Transformer.PROGRESS_STATE_UNAVAILABLE -> {
                                main.postDelayed(this, 500)
                            }
                            else -> { /* NOT_STARTED or terminal */ }
                        }
                    }
                }
                main.postDelayed(poll, 200)

                cont.invokeOnCancellation {
                    main.post { runCatching { transformer.cancel() } }
                }
            }
        }
    }

    private fun fail(msg: String) = Result.failure(workDataOf(KEY_ERROR to msg))

    private fun buildForegroundInfo(
        title: String,
        text: String?,
        percent: Int?,
    ): ForegroundInfo {
        ensureChannel()
        val notification = buildNotification(title, text, percent)
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            ForegroundInfo(
                NOTIFICATION_ID,
                notification,
                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
            )
        } else {
            ForegroundInfo(NOTIFICATION_ID, notification)
        }
    }

    private fun buildNotification(title: String, text: String?, percent: Int?): Notification {
        val cancel = WorkManager.getInstance(applicationContext)
            .createCancelPendingIntent(id)
        val builder = NotificationCompat.Builder(applicationContext, CHANNEL_ID)
            .setSmallIcon(android.R.drawable.stat_sys_upload)
            .setContentTitle(title)
            .setOngoing(true)
            .setOnlyAlertOnce(true)
            .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Cancel", cancel)
        if (text != null) builder.setContentText(text)
        if (percent != null) {
            builder.setProgress(100, percent.coerceIn(0, 100), false)
        } else {
            builder.setProgress(0, 0, true) // indeterminate
        }
        return builder.build()
    }

    private fun ensureChannel() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
        val nm = applicationContext.getSystemService(NotificationManager::class.java) ?: return
        if (nm.getNotificationChannel(CHANNEL_ID) != null) return
        nm.createNotificationChannel(
            NotificationChannel(
                CHANNEL_ID,
                "Video uploads",
                NotificationManager.IMPORTANCE_LOW,
            ).apply { description = "Progress for video uploads" }
        )
    }

    private fun updateNotification(title: String, percent: Int) {
        val nm = NotificationManagerCompat.from(applicationContext)
        if (!nm.areNotificationsEnabled()) return
        runCatching {
            nm.notify(NOTIFICATION_ID, buildNotification(title, "$percent%", percent))
        }
    }

    companion object {
        const val KEY_FILE_PATH = "file_path"
        const val KEY_MIME = "mime"
        const val KEY_QUALITY = "quality"
        const val KEY_THUMB_PATH = "thumb_path"
        const val KEY_UNLISTED = "unlisted"
        const val KEY_PROGRESS = "progress"
        const val KEY_PHASE = "phase"
        const val KEY_CHUNK_INDEX = "chunk_index"   // 1-based for display
        const val KEY_CHUNK_TOTAL = "chunk_total"
        const val KEY_HASH = "hash"
        const val KEY_URL = "url"
        const val KEY_EMBED = "embed"
        const val KEY_THUMBNAIL_URL = "thumbnail_url"
        const val KEY_ERROR = "error"
        const val TAG = "video-upload"

        const val PHASE_COMPRESS = "compress"
        const val PHASE_UPLOAD = "upload"

        private const val CHANNEL_ID = "video-upload"
        private const val NOTIFICATION_ID = 0x5_1A_E1   // arbitrary stable id
    }
}