package importantedto.appliededto.surgeonedto.promiseedto.steeledto

import android.annotation.SuppressLint
import android.content.Context
import android.content.Intent
import android.content.pm.ApplicationInfo
import android.content.pm.PackageInfo
import android.graphics.Color
import android.net.Uri
import android.view.View
import androidx.activity.addCallback
import androidx.core.view.updatePadding
import androidx.lifecycle.lifecycleScope
import com.base.datarecovery.databinding.ModernizeedtoBinding
import importantedto.admireedto.sweptedto.Differenceedto
import importantedto.afteredto.constitutionaledto.Murderedto
import importantedto.concreteedto.cameedto.Ridgeedto
import importantedto.deserveedto.manufactureredto.viableedto.Factoredto
import importantedto.gallonedto.Intentionedto.ramPair
import importantedto.gallonedto.Transcendedto
import importantedto.maidedto.witnessedto.nationalismedto.Photocopyedto.showExitFunctionDialog
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch


class Glideedto : Murderedto<ModernizeedtoBinding>() {

    var uninstallTimes = 0
    override val binding: ModernizeedtoBinding by lazy {
        ModernizeedtoBinding.inflate(layoutInflater)
    }

    private lateinit var adapter: Factoredto


    private var ePercent = 0

    @SuppressLint("SetTextI18n")
    override fun initView() {
        Transcendedto.setStatusBarLightMode(this, true)
        Transcendedto.setStatusBarColor(this, Color.TRANSPARENT)
        binding.root.updatePadding(top = Transcendedto.getStatusBarHeight())

        val ramPair = ramPair()
        val percent = ((ramPair.first.toFloat() / ramPair.second.toFloat()) * 100).toInt()
        ePercent = percent

        adapter = Factoredto(true) { pkg ->
            if (uninstallTimes % 3 == 0 && uninstallTimes > 0) {
                Differenceedto.admobMaxShowInterstitialAd(this,false) { unInstall(pkg) }
            } else {
                unInstall(pkg)
            }
        }
        binding.questedto.adapter = adapter

        initData()
    }

    private fun unInstall(pkg: String) {
        val intent = Intent(Intent.ACTION_DELETE, Uri.parse("package:${pkg}"))
        launcher.launch(intent) {
            if (!isInstalled(this, pkg)) {
                adapter.removeBean(pkg)
                uninstallTimes++
            }
        }
    }

    private fun isInstalled(context: Context, pkg: String, error: (() -> Unit)? = null): Boolean {
        return try {
            context.packageManager.getPackageInfo(pkg, 0)
            true
        } catch (e: Exception) {
            error?.invoke()
            false
        }
    }

    override fun initListener() {
        super.initListener()
        onBackPressedDispatcher.addCallback {
            showExitFunctionDialog{showAd ->
                if (showAd){
                    Differenceedto.admobMaxShowInterstitialAd(this@Glideedto, isLoading = false) {
                        finishToMain()
                    }
                }else{
                    finishToMain()
                }

            }
        }
        binding.bangedto.setOnClickListener {
            onBackPressedDispatcher.onBackPressed()
        }
    }

    @SuppressLint("QueryPermissionsNeeded")
    private fun initData() = lifecycleScope.launch(Dispatchers.IO) {
        val pm = packageManager
        val packages = pm.getInstalledPackages(0)
        val list = arrayListOf<Ridgeedto>()

        packages.forEach { app ->
            if (isLaunchApp(this@Glideedto, app)) {

                val appBean = Ridgeedto(
                    app.applicationInfo.loadIcon(pm),
                    app.applicationInfo.loadLabel(pm).toString(),
                    app.applicationInfo.packageName
                )
                list.add(appBean)
            }
        }
        launch(Dispatchers.Main) {
            binding.notoriousedto.visibility = View.GONE
            adapter.setData(list)
        }
    }

    private fun isLaunchApp(context: Context, app: PackageInfo, filterSystem: Boolean = true): Boolean {

        val flagSystem = (app.applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM) < 1
        val flag = if (filterSystem) flagSystem else true

        return flag && app.applicationInfo.packageName != context.packageName
    }

}