/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.settings.system

import android.content.Context
import android.content.Intent
import android.os.Build
import android.os.PersistableBundle
import android.os.SystemUpdateManager
import android.os.UserManager
import android.telephony.CarrierConfigManager
import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.preference.Preference
import androidx.preference.PreferenceScreen
import com.android.settings.R
import com.android.settings.Utils
import com.android.settings.core.BasePreferenceController
import com.android.settingslib.spaprivileged.framework.common.userManager
import kotlinx.coroutines.launch

open class SystemUpdatePreferenceController(context: Context, preferenceKey: String) :
    BasePreferenceController(context, preferenceKey) {
    private val userManager: UserManager = context.userManager
    private lateinit var preference: Preference

    override fun getAvailabilityStatus() =
        if (mContext.resources.getBoolean(R.bool.config_show_system_update_settings) &&
            userManager.isAdminUser
        ) AVAILABLE else UNSUPPORTED_ON_DEVICE

    override fun displayPreference(screen: PreferenceScreen) {
        super.displayPreference(screen)
        preference = screen.findPreference(preferenceKey)!!
        if (isAvailable) {
            Utils.updatePreferenceToSpecificActivityOrRemove(
                mContext,
                screen,
                preferenceKey,
                Utils.UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY,
            )
        }
    }

    override fun handlePreferenceTreeClick(preference: Preference): Boolean {
        if (preferenceKey == preference.key) {
            val configManager = mContext.getSystemService(CarrierConfigManager::class.java)!!
            configManager.getConfig(CarrierConfigManager.KEY_CI_ACTION_ON_SYS_UPDATE_BOOL)?.let {
                if (it.getBoolean(CarrierConfigManager.KEY_CI_ACTION_ON_SYS_UPDATE_BOOL)) {
                    ciActionOnSysUpdate(it)
                }
            }
        }
        // always return false here because this handler does not want to block other handlers.
        return false
    }

    override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                preference.summary = calculateSummary()
            }
        }
    }

    private suspend fun calculateSummary(): String {
        val updateInfo = mContext.getSystemUpdateInfo() ?: return getReleaseVersionSummary()

        val status = updateInfo.getInt(SystemUpdateManager.KEY_STATUS)
        if (status == SystemUpdateManager.STATUS_UNKNOWN) {
            Log.d(TAG, "Update statue unknown")
        }
        when (status) {
            SystemUpdateManager.STATUS_WAITING_DOWNLOAD,
            SystemUpdateManager.STATUS_IN_PROGRESS,
            SystemUpdateManager.STATUS_WAITING_INSTALL,
            SystemUpdateManager.STATUS_WAITING_REBOOT -> {
                return mContext.getString(R.string.android_version_pending_update_summary)
            }

            SystemUpdateManager.STATUS_IDLE,
            SystemUpdateManager.STATUS_UNKNOWN -> {
                val version = updateInfo.getString(SystemUpdateManager.KEY_TITLE)
                if (!version.isNullOrEmpty()) {
                    return mContext.getString(R.string.android_version_summary, version)
                }
            }
        }
        return getReleaseVersionSummary()
    }

    private fun getReleaseVersionSummary(): String = mContext.getString(
        R.string.android_version_summary,
        Build.VERSION.RELEASE_OR_PREVIEW_DISPLAY,
    )

    /**
     * Trigger client initiated action (send intent) on system update
     */
    private fun ciActionOnSysUpdate(b: PersistableBundle) {
        val intentStr = b.getString(CarrierConfigManager.KEY_CI_ACTION_ON_SYS_UPDATE_INTENT_STRING)
        if (intentStr.isNullOrEmpty()) return
        val extra = b.getString(CarrierConfigManager.KEY_CI_ACTION_ON_SYS_UPDATE_EXTRA_STRING)
        val extraVal =
            b.getString(CarrierConfigManager.KEY_CI_ACTION_ON_SYS_UPDATE_EXTRA_VAL_STRING)
        Log.d(
            TAG,
            "ciActionOnSysUpdate: broadcasting intent $intentStr with extra $extra, $extraVal"
        )
        val intent = Intent(intentStr).apply {
            if (!extra.isNullOrEmpty()) putExtra(extra, extraVal)
            addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND)
        }
        mContext.applicationContext.sendBroadcast(intent)
    }

    companion object {
        private const val TAG = "SysUpdatePrefContr"
    }
}