/*
 * Copyright (C) 2020 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.
 */
@file:Suppress("DEPRECATION")
package com.android.permissioncontroller.permission.ui.model.v31

import android.Manifest
import android.Manifest.permission_group.CAMERA
import android.Manifest.permission_group.LOCATION
import android.Manifest.permission_group.MICROPHONE
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.media.AudioManager
import android.media.AudioManager.MODE_IN_COMMUNICATION
import android.os.Bundle
import android.os.UserHandle
import android.provider.Settings
import android.speech.RecognitionService
import android.speech.RecognizerIntent
import android.telephony.TelephonyManager
import android.telephony.TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS
import android.view.inputmethod.InputMethodManager
import androidx.lifecycle.AbstractSavedStateViewModelFactory
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.savedstate.SavedStateRegistryOwner
import com.android.permissioncontroller.PermissionControllerApplication
import com.android.permissioncontroller.permission.data.AttributionLabelLiveData
import com.android.permissioncontroller.permission.data.LoadAndFreezeLifeData
import com.android.permissioncontroller.permission.data.OpAccess
import com.android.permissioncontroller.permission.data.OpUsageLiveData
import com.android.permissioncontroller.permission.data.PermGroupUsageLiveData
import com.android.permissioncontroller.permission.data.SmartAsyncMediatorLiveData
import com.android.permissioncontroller.permission.data.SmartUpdateMediatorLiveData
import com.android.permissioncontroller.permission.data.micMutedLiveData
import com.android.permissioncontroller.permission.ui.handheld.v31.ReviewOngoingUsageFragment.PHONE_CALL
import com.android.permissioncontroller.permission.ui.handheld.v31.ReviewOngoingUsageFragment.VIDEO_CALL
import com.android.permissioncontroller.permission.utils.KotlinUtils
import com.android.permissioncontroller.permission.utils.KotlinUtils.shouldShowLocationIndicators
import com.android.permissioncontroller.permission.utils.KotlinUtils.shouldShowPermissionsDashboard
import com.android.permissioncontroller.permission.utils.Utils
import java.time.Instant
import kotlin.math.max
import kotlinx.coroutines.Job

private const val FIRST_OPENED_KEY = "FIRST_OPENED"
private const val CALL_OP_USAGE_KEY = "CALL_OP_USAGE"
private const val USAGES_KEY = "USAGES_KEY"
private const val MIC_MUTED_KEY = "MIC_MUTED_KEY"

/**
 * ViewModel for {@link ReviewOngoingUsageFragment}
 */
class ReviewOngoingUsageViewModel(
    state: SavedStateHandle,
    extraDurationMills: Long
) : ViewModel() {
    /** Time of oldest usages considered */
    private val startTime = max(state.get<Long>(FIRST_OPENED_KEY)!! - extraDurationMills,
            Instant.EPOCH.toEpochMilli())

    private val SYSTEM_PKG = "android"

    data class Usages(
        /** attribution-res-id/packageName/user -> perm groups accessed */
        val appUsages: Map<PackageAttribution, Set<String>>,
        /** Op-names of phone call accesses */
        val callUsages: Collection<String>,
        /** A map of attribution, packageName and user -> list of attribution labels to show with
         * microphone*/
        val shownAttributions: Map<PackageAttribution, List<CharSequence>> = emptyMap()
    )

    data class PackageAttribution(
        val attributionTag: String?,
        val packageName: String,
        val user: UserHandle
    ) {
        fun pkgEq(other: PackageAttribution): Boolean {
            return packageName == other.packageName && user == other.user
        }
    }

    /**
     * Base permission usage that will filtered by SystemPermGroupUsages and
     * UserSensitivePermGroupUsages.
     *
     * <p>Note: This does not use a cached live-data to avoid getting stale data
     */
    private val permGroupUsages = LoadAndFreezeLifeData(state, USAGES_KEY,
            PermGroupUsageLiveData(PermissionControllerApplication.get(),
                    if (shouldShowPermissionsDashboard() || shouldShowLocationIndicators()) {
                        listOf(CAMERA, LOCATION, MICROPHONE)
                    } else {
                        listOf(CAMERA, MICROPHONE)
                    }, System.currentTimeMillis() - startTime))

    /**
     * Whether the mic is muted
     */
    private val isMicMuted = LoadAndFreezeLifeData(state, MIC_MUTED_KEY, micMutedLiveData)

    /** App runtime permission usages */
    private val appUsagesLiveData = object : SmartUpdateMediatorLiveData<Map<PackageAttribution,
        Set<String>>>() {
        private val app = PermissionControllerApplication.get()

        init {
            addSource(permGroupUsages) {
                update()
            }

            addSource(isMicMuted) {
                update()
            }
        }

        override fun onUpdate() {
            if (!permGroupUsages.isInitialized || !isMicMuted.isInitialized) {
                return
            }

            if (permGroupUsages.value == null) {
                value = null
                return
            }

            // Filter out system package
            val filteredUsages = mutableMapOf<PackageAttribution, MutableSet<String>>()
            for ((permGroupName, usages) in permGroupUsages.value!!) {
                if (permGroupName == MICROPHONE && isMicMuted.value == true) {
                    continue
                }

                for (usage in usages) {
                    if (usage.packageName != SYSTEM_PKG) {
                        filteredUsages.getOrPut(getPackageAttr(usage),
                                { mutableSetOf() }).add(permGroupName)
                    }
                }
            }

            value = filteredUsages
        }

        // TODO ntmyren: Replace this with better check if this moves beyond teamfood
        private fun isAppPredictor(usage: OpAccess): Boolean {
            return Utils.getUserContext(app, usage.user).packageManager.checkPermission(
                    Manifest.permission.MANAGE_APP_PREDICTIONS, usage.packageName) ==
                    PackageManager.PERMISSION_GRANTED
        }
    }

    /**
     * Gets all trusted proxied voice IME and voice recognition microphone uses, and get the
     * label needed to display with it, as well as information about the proxy whose label is being
     * shown, if applicable.
     */
    private val trustedAttrsLiveData = object : SmartAsyncMediatorLiveData<
        Map<PackageAttribution, CharSequence>>() {
        private val VOICE_IME_SUBTYPE = "voice"

        private val attributionLabelLiveDatas =
            mutableMapOf<Triple<String?, String, UserHandle>, AttributionLabelLiveData>()

        init {
            addSource(permGroupUsages) {
                updateAsync()
            }
        }

        override suspend fun loadDataAndPostValue(job: Job) {
            if (!permGroupUsages.isInitialized) {
                return
            }
            val usages = permGroupUsages.value?.get(MICROPHONE) ?: run {
                postValue(emptyMap())
                return
            }
            val proxies = usages.mapNotNull { it.proxyAccess }

            val proxyLabelLiveDatas = proxies.map {
                Triple(it.attributionTag, it.packageName, it.user) }
            val toAddLabelLiveDatas = (usages.map { Triple(it.attributionTag, it.packageName,
                it.user) } + proxyLabelLiveDatas).distinct()
            val getLiveDataFun = { key: Triple<String?, String, UserHandle> ->
                AttributionLabelLiveData[key] }
            setSourcesToDifference(toAddLabelLiveDatas, attributionLabelLiveDatas, getLiveDataFun)

            if (attributionLabelLiveDatas.any { !it.value.isInitialized }) {
                return
            }

            val approvedAttrs = mutableMapOf<PackageAttribution, String>()
            for (user in usages.map { it.user }.distinct()) {
                val userContext = Utils.getUserContext(PermissionControllerApplication.get(), user)

                // TODO ntmyren: Observe changes, possibly split into separate LiveDatas
                val voiceInputs = mutableMapOf<String, CharSequence>()
                userContext.getSystemService(InputMethodManager::class.java)!!
                    .enabledInputMethodList.forEach {
                        for (i in 0 until it.subtypeCount) {
                            if (it.getSubtypeAt(i).mode == VOICE_IME_SUBTYPE) {
                                voiceInputs[it.packageName] =
                                    it.serviceInfo.loadSafeLabel(userContext.packageManager,
                                        Float.MAX_VALUE, 0)
                                break
                            }
                        }
                    }

                // Get the currently selected recognizer from the secure setting.
                val recognitionPackageName = Settings.Secure.getString(userContext.contentResolver,
                    // Settings.Secure.VOICE_RECOGNITION_SERVICE
                    "voice_recognition_service")
                    ?.let(ComponentName::unflattenFromString)?.packageName

                val recognizers = mutableMapOf<String, CharSequence>()
                val availableRecognizers = userContext.packageManager.queryIntentServices(
                    Intent(RecognitionService.SERVICE_INTERFACE), PackageManager.GET_META_DATA)
                availableRecognizers.forEach {
                    val sI = it.serviceInfo
                    if (sI.packageName == recognitionPackageName) {
                        recognizers[sI.packageName] = sI.loadSafeLabel(userContext.packageManager,
                        Float.MAX_VALUE, 0)
                    }
                }

                val recognizerIntents = mutableMapOf<String, CharSequence>()
                val availableRecognizerIntents = userContext.packageManager.queryIntentActivities(
                    Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), PackageManager.GET_META_DATA)
                availableRecognizers.forEach { rI ->
                    val servicePkg = rI.serviceInfo.packageName
                    if (servicePkg == recognitionPackageName && availableRecognizerIntents.any {
                            it.activityInfo.packageName == servicePkg }) {
                        // If this recognizer intent is also a recognizer service, and is trusted,
                        // Then attribute to voice recognition
                        recognizerIntents[servicePkg] =
                            rI.serviceInfo.loadSafeLabel(userContext.packageManager,
                                Float.MAX_VALUE, 0)
                    }
                }

                // get attribution labels for voice IME, recognition intents, and recognition
                // services
                for (opAccess in usages) {
                    setTrustedAttrsForAccess(userContext, opAccess, user, false, voiceInputs,
                        approvedAttrs)
                    setTrustedAttrsForAccess(userContext, opAccess, user, false, recognizerIntents,
                        approvedAttrs)
                    setTrustedAttrsForAccess(userContext, opAccess, user, true, recognizers,
                        approvedAttrs)
                }
            }
            postValue(approvedAttrs)
        }

        private fun setTrustedAttrsForAccess(
            context: Context,
            opAccess: OpAccess,
            currUser: UserHandle,
            getProxyLabel: Boolean,
            trustedMap: Map<String, CharSequence>,
            toSetMap: MutableMap<PackageAttribution, String>
        ) {
            val access = if (getProxyLabel) {
                opAccess.proxyAccess
            } else {
                opAccess
            }

            if (access == null || access.user != currUser || access.packageName !in trustedMap) {
                return
            }

            val appAttr = getPackageAttr(access)
            val packageName = access.packageName

            val labelResId = attributionLabelLiveDatas[Triple(access.attributionTag,
                access.packageName, access.user)]?.value ?: 0
            val label = try {
                context.createPackageContext(packageName, 0)
                    .getString(labelResId)
            } catch (e: Exception) {
                return
            }
            if (trustedMap[packageName] == label) {
                toSetMap[appAttr] = label
            }
        }
    }

    /**
     * Get all chains of proxy usages. A proxy chain is defined as one usage at the root, then
     * further proxy usages, where the app and attribution tag of the proxy matches the previous
     * usage in the chain.
     */
    private val proxyChainsLiveData = object : SmartUpdateMediatorLiveData<Set<List<OpAccess>>>() {
        init {
            addSource(permGroupUsages) {
                update()
            }
        }
        override fun onUpdate() {
            if (!permGroupUsages.isInitialized) {
                return
            }
            val usages = permGroupUsages.value?.get(MICROPHONE) ?: emptyList()
            // a map of chain start -> in progress chain
            val proxyChains = mutableMapOf<PackageAttribution, MutableList<OpAccess>>()

            val remainingProxyChainUsages = mutableMapOf<PackageAttribution, OpAccess>()
            for (usage in usages) {
                remainingProxyChainUsages[getPackageAttr(usage)] = usage
            }
            // find all one-link chains (that is, all proxied apps whose proxy is not included in
            // the usage list)
            for (usage in usages) {
                val usageAttr = getPackageAttr(usage)
                val proxyAttr = getPackageAttr(usage.proxyAccess ?: continue)
                if (!usages.any { getPackageAttr(it) == proxyAttr }) {
                    proxyChains[usageAttr] = mutableListOf(usage)
                    remainingProxyChainUsages.remove(usageAttr)
                }
            }

            // find all possible starting points for chains
            for ((usageAttr, usage) in remainingProxyChainUsages.toMap()) {
                // If this usage has a proxy, but is not a proxy, it is the start of a chain.
                // If it has no proxy, and isn't a proxy, remove it.
                if (!remainingProxyChainUsages.values.any { it.proxyAccess != null &&
                                getPackageAttr(it.proxyAccess) == usageAttr }) {
                    if (usage.proxyAccess != null) {
                        proxyChains[usageAttr] = mutableListOf(usage)
                    } else {
                        remainingProxyChainUsages.remove(usageAttr)
                    }
                }
            }

            // assemble the chains
            for ((startUsageAttr, proxyChain) in proxyChains) {
                var currentUsage = remainingProxyChainUsages[startUsageAttr] ?: continue
                while (currentUsage.proxyAccess != null) {
                    val currPackageAttr = getPackageAttr(currentUsage.proxyAccess!!)
                    currentUsage = remainingProxyChainUsages[currPackageAttr] ?: break
                    if (proxyChain.any { it == currentUsage }) {
                        // we have a cycle, and should break
                        break
                    }
                    proxyChain.add(currentUsage)
                }
                // invert the lists, so the element without a proxy is first on the list
                proxyChain.reverse()
            }

            value = proxyChains.values.toSet()
        }
    }

    /** Phone call usages */
    private val callOpUsageLiveData =
        object : SmartUpdateMediatorLiveData<Collection<String>>() {
            private val rawOps = LoadAndFreezeLifeData(state, CALL_OP_USAGE_KEY,
                OpUsageLiveData[listOf(PHONE_CALL, VIDEO_CALL),
                    System.currentTimeMillis() - startTime])

            init {
                addSource(rawOps) {
                    update()
                }

                addSource(isMicMuted) {
                    update()
                }
            }

            override fun onUpdate() {
                if (!isMicMuted.isInitialized || !rawOps.isInitialized) {
                    return
                }

                value = if (isMicMuted.value == true) {
                    rawOps.value!!.keys.filter { it != PHONE_CALL }
                } else {
                    rawOps.value!!.keys
                }
            }
        }

    /** App, system, and call usages in a single, nice, handy package */
    val usages = object : SmartAsyncMediatorLiveData<Usages>() {
        private val app = PermissionControllerApplication.get()

        init {
            addSource(appUsagesLiveData) {
                update()
            }

            addSource(callOpUsageLiveData) {
                update()
            }

            addSource(trustedAttrsLiveData) {
                update()
            }

            addSource(proxyChainsLiveData) {
                update()
            }
        }

        override suspend fun loadDataAndPostValue(job: Job) {
            if (job.isCancelled) {
                return
            }

            if (!callOpUsageLiveData.isInitialized || !appUsagesLiveData.isInitialized ||
                !trustedAttrsLiveData.isInitialized || !proxyChainsLiveData.isInitialized) {
                return
            }

            val callOpUsages = callOpUsageLiveData.value?.toMutableSet()
            val appUsages = appUsagesLiveData.value?.toMutableMap()
            val approvedAttrs = trustedAttrsLiveData.value?.toMutableMap() ?: mutableMapOf()
            val proxyChains = proxyChainsLiveData.value ?: emptySet()

            if (callOpUsages == null || appUsages == null) {
                postValue(null)
                return
            }

            // If there is nothing to show the dialog should be closed, hence return a "invalid"
            // value
            if (appUsages.isEmpty() && callOpUsages.isEmpty()) {
                postValue(null)
                return
            }

            // If we are in a VOIP call (aka MODE_IN_COMMUNICATION), and have a carrier privileged
            // app using the mic, hide phone usage.
            val audioManager = app.getSystemService(AudioManager::class.java)!!
            if (callOpUsages.isNotEmpty() && audioManager.mode == MODE_IN_COMMUNICATION) {
                val telephonyManager = app.getSystemService(TelephonyManager::class.java)!!
                for ((pkg, usages) in appUsages) {
                    if (telephonyManager.checkCarrierPrivilegesForPackage(pkg.packageName) ==
                        CARRIER_PRIVILEGE_STATUS_HAS_ACCESS && usages.contains(MICROPHONE)) {
                        callOpUsages.clear()
                        continue
                    }
                }
            }

            // Find labels for proxies, and assign them to the proper app, removing other usages
            val approvedLabels = mutableMapOf<PackageAttribution, List<CharSequence>>()
            for (chain in proxyChains) {
                // if the final link in the chain is not user sensitive, do not show the chain
                if (getPackageAttr(chain[chain.size - 1]) !in appUsages) {
                    continue
                }

                // if the proxy access is missing, for some reason, do not show the proxy
                if (chain.size == 1) {
                    continue
                }

                val labels = mutableListOf<CharSequence>()
                for ((idx, opAccess) in chain.withIndex()) {
                    val appAttr = getPackageAttr(opAccess)
                    // If this is the last link in the proxy chain, assign it the series of labels
                    // Else, if it has a special label, add that label
                    // Else, if there are no other apps in the remaining part of the chain which
                    // have the same package name, add the app label
                    // If it is not the last link in the chain, remove its attribution
                    if (idx == chain.size - 1) {
                        approvedLabels[appAttr] = labels
                        continue
                    } else if (appAttr in approvedAttrs) {
                        labels.add(approvedAttrs[appAttr]!!)
                        approvedAttrs.remove(appAttr)
                    } else if (chain.subList(idx + 1, chain.size).all {
                            it.packageName != opAccess.packageName } &&
                            opAccess.packageName != SYSTEM_PKG) {
                        labels.add(KotlinUtils.getPackageLabel(app, opAccess.packageName,
                            opAccess.user))
                    }
                    appUsages.remove(appAttr)
                }
            }

            // Any remaining truested attributions must be for non-proxy usages, so add them
            for ((packageAttr, label) in approvedAttrs) {
                approvedLabels[packageAttr] = listOf(label)
            }

            removeDuplicates(appUsages, approvedLabels.keys)

            postValue(Usages(appUsages, callOpUsages, approvedLabels))
        }

        /**
         * Merge any usages for the same app which don't have a special attribution
         */
        private fun removeDuplicates(
            appUsages: MutableMap<PackageAttribution, Set<String>>,
            approvedUsages: Collection<PackageAttribution>
        ) {
            // Iterate over all non-special attribution keys
            for (packageAttr in appUsages.keys.minus(approvedUsages)) {
                var groupSet = appUsages[packageAttr] ?: continue

                for (otherAttr in appUsages.keys.minus(approvedUsages)) {
                    if (otherAttr.pkgEq(packageAttr)) {
                        groupSet = groupSet.plus(appUsages[otherAttr] ?: emptySet())
                        appUsages.remove(otherAttr)
                    }
                }
                appUsages[packageAttr] = groupSet
            }
        }
    }

    private fun getPackageAttr(usage: OpAccess): PackageAttribution {
        return PackageAttribution(usage.attributionTag, usage.packageName, usage.user)
    }
}

/**
 * Factory for a ReviewOngoingUsageViewModel
 *
 * @param extraDurationMillis The number of milliseconds old usages are considered for
 * @param owner The owner of this saved state
 * @param defaultArgs The default args to pass
 */
class ReviewOngoingUsageViewModelFactory(
    private val extraDurationMillis: Long,
    owner: SavedStateRegistryOwner,
    defaultArgs: Bundle
) : AbstractSavedStateViewModelFactory(owner, defaultArgs) {
    override fun <T : ViewModel> create(
        key: String,
        modelClass: Class<T>,
        handle: SavedStateHandle
    ): T {
        handle.set(FIRST_OPENED_KEY, handle.get<Long>(FIRST_OPENED_KEY)
            ?: System.currentTimeMillis())
        @Suppress("UNCHECKED_CAST")
        return ReviewOngoingUsageViewModel(handle, extraDurationMillis) as T
    }
}