/*
 * 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.
 */

package com.android.permissioncontroller.permission.ui.model

import android.Manifest
import android.app.AppOpsManager
import android.app.AppOpsManager.MODE_ALLOWED
import android.app.AppOpsManager.MODE_IGNORED
import android.app.AppOpsManager.OPSTR_AUTO_REVOKE_PERMISSIONS_IF_UNUSED
import android.apphibernation.AppHibernationManager
import android.content.Context
import android.os.Bundle
import android.os.UserHandle
import android.util.Log
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import com.android.permissioncontroller.PermissionControllerApplication
import com.android.permissioncontroller.PermissionControllerStatsLog
import com.android.permissioncontroller.PermissionControllerStatsLog.APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION
import com.android.permissioncontroller.PermissionControllerStatsLog.APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION__ACTION__SWITCH_DISABLED
import com.android.permissioncontroller.PermissionControllerStatsLog.APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION__ACTION__SWITCH_ENABLED
import com.android.permissioncontroller.R
import com.android.permissioncontroller.hibernation.isHibernationEnabled
import com.android.permissioncontroller.permission.data.AppPermGroupUiInfoLiveData
import com.android.permissioncontroller.permission.data.FullStoragePermissionAppsLiveData
import com.android.permissioncontroller.permission.data.HibernationSettingStateLiveData
import com.android.permissioncontroller.permission.data.LightPackageInfoLiveData
import com.android.permissioncontroller.permission.data.PackagePermissionsLiveData
import com.android.permissioncontroller.permission.data.PackagePermissionsLiveData.Companion.NON_RUNTIME_NORMAL_PERMS
import com.android.permissioncontroller.permission.data.SmartUpdateMediatorLiveData
import com.android.permissioncontroller.permission.data.get
import com.android.permissioncontroller.permission.model.AppPermissionUsage
import com.android.permissioncontroller.permission.model.livedatatypes.AppPermGroupUiInfo.PermGrantState
import com.android.permissioncontroller.permission.ui.Category
import com.android.permissioncontroller.permission.utils.IPC
import com.android.permissioncontroller.permission.utils.Utils
import com.android.permissioncontroller.permission.utils.Utils.AppPermsLastAccessType
import com.android.permissioncontroller.permission.utils.navigateSafe
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import java.time.Instant
import java.util.concurrent.TimeUnit
import kotlin.math.max

/**
 * ViewModel for the AppPermissionGroupsFragment. Has a liveData with the UI information for all
 * permission groups that this package requests runtime permissions from
 *
 * @param packageName The name of the package this viewModel is representing
 * @param user The user of the package this viewModel is representing
 */
class AppPermissionGroupsViewModel(
    private val packageName: String,
    private val user: UserHandle,
    private val sessionId: Long
) : ViewModel() {

    companion object {
        const val AGGREGATE_DATA_FILTER_BEGIN_DAYS = 1
        val LOG_TAG: String = AppPermissionGroupsViewModel::class.java.simpleName
    }

    val app = PermissionControllerApplication.get()!!

    enum class PermSubtitle(val value: Int) {
        NONE(0),
        MEDIA_ONLY(1),
        ALL_FILES(2),
        FOREGROUND_ONLY(3),
        BACKGROUND(4),
    }

    data class GroupUiInfo(
        val groupName: String,
        val isSystem: Boolean = false,
        val subtitle: PermSubtitle
    ) {
        constructor(groupName: String, isSystem: Boolean) :
            this(groupName, isSystem, PermSubtitle.NONE)
    }

    // Auto-revoke and hibernation share the same settings
    val autoRevokeLiveData = HibernationSettingStateLiveData[packageName, user]

    /**
     * LiveData whose data is a map of grant category (either allowed or denied) to a list
     * of permission group names that match the key, and two booleans representing if this is a
     * system group, and a subtitle resource ID, if applicable.
     */
    val packagePermGroupsLiveData = object : SmartUpdateMediatorLiveData<@JvmSuppressWildcards
    Map<Category, List<GroupUiInfo>>>() {

        private val packagePermsLiveData =
            PackagePermissionsLiveData[packageName, user]
        private val appPermGroupUiInfoLiveDatas = mutableMapOf<String, AppPermGroupUiInfoLiveData>()
        private val fullStoragePermsLiveData = FullStoragePermissionAppsLiveData

        init {
            addSource(packagePermsLiveData) {
                update()
            }
            addSource(fullStoragePermsLiveData) {
                update()
            }
            addSource(autoRevokeLiveData) {
                removeSource(autoRevokeLiveData)
                update()
            }
            update()
        }

        override fun onUpdate() {
            val groups = packagePermsLiveData.value?.keys?.filter { it != NON_RUNTIME_NORMAL_PERMS }
            if (groups == null && packagePermsLiveData.isInitialized) {
                value = null
                return
            } else if (groups == null || (Manifest.permission_group.STORAGE in groups &&
                    !fullStoragePermsLiveData.isInitialized) || !autoRevokeLiveData.isInitialized) {
                return
            }

            val getLiveData = { groupName: String ->
                AppPermGroupUiInfoLiveData[packageName, groupName, user]
            }
            setSourcesToDifference(groups, appPermGroupUiInfoLiveDatas, getLiveData)

            if (!appPermGroupUiInfoLiveDatas.all { it.value.isInitialized }) {
                return
            }

            val groupGrantStates = mutableMapOf<Category,
                MutableList<GroupUiInfo>>()
            groupGrantStates[Category.ALLOWED] = mutableListOf()
            groupGrantStates[Category.ASK] = mutableListOf()
            groupGrantStates[Category.DENIED] = mutableListOf()

            val fullStorageState = fullStoragePermsLiveData.value?.find { pkg ->
                pkg.packageName == packageName && pkg.user == user
            }

            for (groupName in groups) {
                val isSystem = Utils.getPlatformPermissionGroups().contains(groupName)
                appPermGroupUiInfoLiveDatas[groupName]?.value?.let { uiInfo ->
                    if (groupName == Manifest.permission_group.STORAGE &&
                        (fullStorageState?.isGranted == true && !fullStorageState.isLegacy)) {
                        groupGrantStates[Category.ALLOWED]!!.add(
                            GroupUiInfo(groupName, isSystem, PermSubtitle.ALL_FILES))
                        return@let
                    }
                    when (uiInfo.permGrantState) {
                        PermGrantState.PERMS_ALLOWED -> {
                            val subtitle = if (groupName == Manifest.permission_group.STORAGE) {
                                if (fullStorageState?.isLegacy == true) {
                                    PermSubtitle.ALL_FILES
                                } else {
                                    PermSubtitle.MEDIA_ONLY
                                }
                            } else {
                                PermSubtitle.NONE
                            }
                            groupGrantStates[Category.ALLOWED]!!.add(
                                GroupUiInfo(groupName, isSystem, subtitle))
                        }
                        PermGrantState.PERMS_ALLOWED_ALWAYS -> groupGrantStates[
                            Category.ALLOWED]!!.add(GroupUiInfo(groupName, isSystem,
                                PermSubtitle.BACKGROUND))
                        PermGrantState.PERMS_ALLOWED_FOREGROUND_ONLY -> groupGrantStates[
                            Category.ALLOWED]!!.add(GroupUiInfo(groupName, isSystem,
                                PermSubtitle.FOREGROUND_ONLY))
                        PermGrantState.PERMS_DENIED -> groupGrantStates[Category.DENIED]!!.add(
                            GroupUiInfo(groupName, isSystem))
                        PermGrantState.PERMS_ASK -> groupGrantStates[Category.ASK]!!.add(
                            GroupUiInfo(groupName, isSystem))
                    }
                }
            }

            value = groupGrantStates
        }
    }

    fun setAutoRevoke(enabled: Boolean) {
        GlobalScope.launch(IPC) {
            val aom = app.getSystemService(AppOpsManager::class.java)!!
            val uid = LightPackageInfoLiveData[packageName, user].getInitializedValue()?.uid

            if (uid != null) {
                Log.i(LOG_TAG, "sessionId $sessionId setting auto revoke enabled to $enabled for" +
                    "$packageName $user")
                val tag = if (enabled) {
                    APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION__ACTION__SWITCH_ENABLED
                } else {
                    APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION__ACTION__SWITCH_DISABLED
                }
                PermissionControllerStatsLog.write(
                    APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION, sessionId, uid, packageName,
                    tag)

                val mode = if (enabled) {
                    MODE_ALLOWED
                } else {
                    MODE_IGNORED
                }
                aom.setUidMode(OPSTR_AUTO_REVOKE_PERMISSIONS_IF_UNUSED, uid, mode)
                if (isHibernationEnabled() && !enabled) {
                    val ahm = app.getSystemService(AppHibernationManager::class.java)!!
                    ahm.setHibernatingForUser(packageName, false)
                    ahm.setHibernatingGlobally(packageName, false)
                }
            }
        }
    }

    fun showExtraPerms(fragment: Fragment, args: Bundle) {
        fragment.findNavController().navigateSafe(R.id.perm_groups_to_custom, args)
    }

    fun showAllPermissions(fragment: Fragment, args: Bundle) {
        fragment.findNavController().navigateSafe(R.id.perm_groups_to_all_perms, args)
    }

    // This method should be consolidated with
    // PermissionAppsViewModel#extractGroupUsageLastAccessTime
    fun extractGroupUsageLastAccessTime(
        accessTime: MutableMap<String, Long>,
        appPermissionUsages: List<AppPermissionUsage>,
        packageName: String
    ) {
        accessTime.clear()
        val filterTimeBeginMillis = max(System.currentTimeMillis() -
                TimeUnit.DAYS.toMillis(AGGREGATE_DATA_FILTER_BEGIN_DAYS.toLong()),
                Instant.EPOCH.toEpochMilli())
        val numApps: Int = appPermissionUsages.size
        for (appIndex in 0 until numApps) {
            val appUsage: AppPermissionUsage = appPermissionUsages[appIndex]
            if (appUsage.packageName != packageName) {
                continue
            }
            val appGroups = appUsage.groupUsages
            val numGroups = appGroups.size
            for (groupIndex in 0 until numGroups) {
                val groupUsage = appGroups[groupIndex]
                var lastAccessTime = groupUsage.lastAccessTime
                val groupName = groupUsage.group.name
                if (lastAccessTime == 0L || lastAccessTime < filterTimeBeginMillis) {
                    continue
                }

                // We might have another AppPermissionUsage entry that's of the same packageName
                // but with a different uid. In that case, we want to grab the max lastAccessTime
                // as the last usage to show.
                lastAccessTime = Math.max(
                        accessTime.getOrDefault(groupName, Instant.EPOCH.toEpochMilli()),
                        lastAccessTime)
                accessTime[groupName] = lastAccessTime
            }
        }
    }

    fun getPreferenceSummary(groupInfo: GroupUiInfo, context: Context, lastAccessTime: Long?):
            String {
        val summaryTimestamp = Utils
                .getPermissionLastAccessSummaryTimestamp(
                        lastAccessTime, context, groupInfo.groupName)
        @AppPermsLastAccessType val lastAccessType: Int = summaryTimestamp.second

        return when (groupInfo.subtitle) {
            PermSubtitle.BACKGROUND ->
                when (lastAccessType) {
                    Utils.LAST_24H_CONTENT_PROVIDER -> context.getString(
                            R.string.app_perms_content_provider_background)
                    Utils.LAST_24H_SENSOR_TODAY -> context.getString(
                            R.string.app_perms_24h_access_background,
                            summaryTimestamp.first)
                    Utils.LAST_24H_SENSOR_YESTERDAY -> context.getString(
                            R.string.app_perms_24h_access_yest_background,
                            summaryTimestamp.first)
                    Utils.NOT_IN_LAST_24H -> context.getString(
                            R.string.permission_subtitle_background)
                    else -> context.getString(
                            R.string.permission_subtitle_background)
                }
            PermSubtitle.MEDIA_ONLY ->
                when (lastAccessType) {
                    Utils.LAST_24H_CONTENT_PROVIDER -> context.getString(
                            R.string.app_perms_content_provider_media_only)
                    Utils.LAST_24H_SENSOR_TODAY -> context.getString(
                            R.string.app_perms_24h_access_media_only,
                            summaryTimestamp.first)
                    Utils.LAST_24H_SENSOR_YESTERDAY -> context.getString(
                            R.string.app_perms_24h_access_yest_media_only,
                            summaryTimestamp.first)
                    Utils.NOT_IN_LAST_24H -> context.getString(
                            R.string.permission_subtitle_media_only)
                    else -> context.getString(R.string.permission_subtitle_media_only)
                }
            PermSubtitle.ALL_FILES ->
                when (lastAccessType) {
                    Utils.LAST_24H_CONTENT_PROVIDER -> context.getString(
                            R.string.app_perms_content_provider_all_files)
                    Utils.LAST_24H_SENSOR_TODAY -> context.getString(
                            R.string.app_perms_24h_access_all_files,
                            summaryTimestamp.first)
                    Utils.LAST_24H_SENSOR_YESTERDAY -> context.getString(
                            R.string.app_perms_24h_access_yest_all_files,
                            summaryTimestamp.first)
                    Utils.NOT_IN_LAST_24H -> context.getString(
                            R.string.permission_subtitle_all_files)
                    else -> context.getString(R.string.permission_subtitle_all_files)
                }
            PermSubtitle.FOREGROUND_ONLY ->
                when (lastAccessType) {
                    Utils.LAST_24H_CONTENT_PROVIDER -> context.getString(
                            R.string.app_perms_content_provider)
                    Utils.LAST_24H_SENSOR_TODAY -> context.getString(
                            R.string.app_perms_24h_access,
                            summaryTimestamp.first)
                    Utils.LAST_24H_SENSOR_YESTERDAY -> context.getString(
                            R.string.app_perms_24h_access_yest,
                            summaryTimestamp.first)
                    Utils.NOT_IN_LAST_24H -> ""
                    else -> ""
                }
            else ->
                when (lastAccessType) {
                    Utils.LAST_24H_CONTENT_PROVIDER -> context.getString(
                            R.string.app_perms_content_provider)
                    Utils.LAST_24H_SENSOR_TODAY -> context.getString(
                            R.string.app_perms_24h_access,
                            summaryTimestamp.first)
                    Utils.LAST_24H_SENSOR_YESTERDAY -> context.getString(
                            R.string.app_perms_24h_access_yest,
                            summaryTimestamp.first)
                    Utils.NOT_IN_LAST_24H -> ""
                    else -> ""
                }
        }
    }
}

/**
 * Factory for an AppPermissionGroupsViewModel
 *
 * @param packageName The name of the package this viewModel is representing
 * @param user The user of the package this viewModel is representing
 */
class AppPermissionGroupsViewModelFactory(
    private val packageName: String,
    private val user: UserHandle,
    private val sessionId: Long
) : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        @Suppress("UNCHECKED_CAST")
        return AppPermissionGroupsViewModel(packageName, user, sessionId) as T
    }
}