package com.gramiatechnologies.gramia

import android.content.Context
import android.util.Log
import androidx.work.BackoffPolicy
import androidx.work.Constraints
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.NetworkType
import androidx.work.PeriodicWorkRequestBuilder
import androidx.work.WorkManager
import androidx.work.workDataOf
import java.util.concurrent.TimeUnit

object NotificationPollingScheduler {
    private const val PREFS_NAME = "easiwrap_prefs"
    private const val WORK_NAME = "notificationPolling"

    fun schedule(
        context: Context,
        institutionUserId: String,
        userId: String,
        apiToken: String
    ) {
        if (institutionUserId.isBlank() || userId.isBlank()) return

        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
            .edit()
            .putString("last_institution_user_id", institutionUserId)
            .putString("user_id", userId)
            .putString("api_token", apiToken)
            .apply()

        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .build()
        val inputData = workDataOf(
            "institution_user_id" to institutionUserId,
            "userId" to userId,
            "apiToken" to apiToken
        )
        val request = PeriodicWorkRequestBuilder<NotificationWorker>(15, TimeUnit.MINUTES)
            .setConstraints(constraints)
            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
            .setInputData(inputData)
            .build()

        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
            WORK_NAME,
            ExistingPeriodicWorkPolicy.UPDATE,
            request
        )
        Log.i("NotificationPolling", "Background polling scheduled for account $institutionUserId")
    }

    data class RegistrationContext(
        val institutionUserId: String,
        val userId: String,
        val apiToken: String
    )

    fun restore(context: Context): RegistrationContext? {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val institutionUserId = prefs.getString("last_institution_user_id", "").orEmpty()
        val userId = prefs.getString("user_id", "").orEmpty()
        if (institutionUserId.isBlank() || userId.isBlank()) {
            Log.i("NotificationPolling", "No signed-in account available for background polling")
            return null
        }

        val apiToken = prefs.getString("api_token", "").orEmpty()

        schedule(
            context,
            institutionUserId,
            userId,
            apiToken
        )
        return RegistrationContext(institutionUserId, userId, apiToken)
    }

    fun cancel(context: Context) {
        WorkManager.getInstance(context).cancelUniqueWork(WORK_NAME)
        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
            .edit()
            .remove("last_institution_user_id")
            .remove("user_id")
            .remove("api_token")
            .apply()
        Log.i("NotificationPolling", "Background polling cancelled")
    }
}