package moe.yuuta.workmode.access

import android.content.pm.ApplicationInfo
import android.os.*
import com.elvishew.xlog.XLog
import moe.yuuta.workmode.R
import moe.yuuta.workmode.suspend.data.TransferableSuspendedApp
import moe.yuuta.workmode.utils.BundleUtils
import java.util.stream.Collectors

/**
 * Provides some quick accesses of AccessLayer
 */
internal class AccessLayerUtil(private val accessLayer: AccessLayer) {
    private val logger = XLog.tag("ALUtil").build()

    fun collectUserIDs(packages: List<TransferableSuspendedApp>): Map<Int /* user id */, List<TransferableSuspendedApp>> {
        // Collect them with specified user ids
        val packagesWithUserIds = mutableMapOf<Int /* user id */, List<TransferableSuspendedApp>>()
        packages.stream()
                .forEach {
                    val list = packagesWithUserIds[it.userId]?.toMutableList() ?: mutableListOf()
                    list.add(it)
                    packagesWithUserIds[it.userId] = list
                }
        return packagesWithUserIds
    }

    fun suspend(packages: List<TransferableSuspendedApp>,
                        suspended: Boolean,
                        appExtras: BaseBundle,
                        launcherExtras: BaseBundle,
                        dialogMessage: String?,
                        hostInfo: HostInfo): Array<String> {
        val packagesWithUserIds = collectUserIDs(packages)

        val result = mutableListOf<String>()
        for (userId in packagesWithUserIds.keys) {
            result.addAll(accessLayer.setPackagesSuspended(
                    packagesWithUserIds[userId]!!.stream()
                            .map { return@map it.packageName }
                            .collect(Collectors.toList()).toTypedArray(),
                    suspended,
                    when (appExtras) {
                        is PersistableBundle -> appExtras
                        is Bundle -> BundleUtils.toPersistableBundle(appExtras)
                        else -> PersistableBundle()
                    },
                    when (launcherExtras) {
                        is PersistableBundle -> launcherExtras
                        is Bundle -> BundleUtils.toPersistableBundle(launcherExtras)
                        else -> PersistableBundle()
                    }, if (dialogMessage == null) {
                            if (userId == hostInfo.userId ||
                                    userId == UserHandle.USER_OWNER) accessLayer.mContext.getString(R.string.suspended_message)
                            else accessLayer.mContext.getString(R.string.suspended_message_managed)
                        } else dialogMessage,
                    userId))
        }
        return result.toTypedArray()
    }

    fun suspend(packages: List<TransferableSuspendedApp>, suspended: Boolean, hostInfo: HostInfo): Array<String> =
            suspend(packages,
                    suspended,
                    Bundle(),
                    PersistableBundle(), // Removed because there is an unknown bug which prevents from writing launcher extras from the owner (?)
                    null,
                    hostInfo)

    fun getSuspendedPackageAppExtras(packageInfo: TransferableSuspendedApp): PersistableBundle? =
            accessLayer.getSuspendedPackageAppExtras(packageName = packageInfo.packageName,
                    userId = packageInfo.userId)

    fun isPackageSuspended(packageInfo: TransferableSuspendedApp): Boolean =
            accessLayer.isPackageSuspended(packageName = packageInfo.packageName,
                    userId = packageInfo.userId)

    fun getSuspendedPackageLauncherExtras(packageInfo: TransferableSuspendedApp): Bundle? =
            accessLayer.getSuspendedPackageLauncherExtras(packageName = packageInfo.packageName,
                    userId = packageInfo.userId)

    fun getInstalledApplicationsAsUser(flags: Int, userId: Int): List<ApplicationInfo> =
            accessLayer.getInstalledApplicationsAsUser(flags, userId)

    fun getInstalledApplicationsAnyUser(flags: Int): List<ApplicationInfo> {
        val userManager = accessLayer.mContext.getSystemService(UserManager::class.java)
        val finalResult = mutableListOf<ApplicationInfo>()
        val ids = userManager.getUsers(false)
                .stream()
                .map {
                    return@map it.id
                }
                .collect(Collectors.toList())
                .toTypedArray()

        for (userHandle in ids) {
            finalResult.addAll(getInstalledApplicationsAsUser(flags,
                    userHandle.hashCode()))
        }
        // val result = accessLayer.getInstalledApplicationsAsUser(flags or
        //         PackageManager::class.java.getDeclaredField("MATCH_ANY_USER").getInt(null),
        //         0 /* System */)
        return finalResult
    }
}