package aicg.wipf.keyu.bzsb

import aicg.wipf.rxxn.Qczw
import aicg.wipf.vzuj.Hqlm
import aicg.wipf.vzuj.Kmqp.string
import aicg.wipf.vzuj.Npaq
import aicg.wipf.vzuj.Tgsx
import aicg.wipf.vzuj.bcxo.Fnpc
import android.animation.ValueAnimator
import android.content.Intent
import android.graphics.Color
import android.util.Log
import android.view.animation.LinearInterpolator
import androidx.core.animation.doOnEnd
import androidx.core.view.updatePadding
import com.blankj.utilcode.util.BarUtils
import com.test.basd.smartjunkcleaner.R
import com.test.basd.smartjunkcleaner.databinding.VglyzwBinding
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import java.io.File
import kotlin.random.Random

class Fnxq : Hqlm<VglyzwBinding>() {

    override val binding: VglyzwBinding by lazy {
        class ޥޗޑލޟބޑގ<T>(val ޝޒއތވވޅޠ: T)
        val ފއޑޔޑދޖޕ = ޥޗޑލޟބޑގ(1231)
        val މޙޗތޅޣޡޙ = ޥޗޑލޟބޑގ("ޢޗޕޡޛއޤޝ")
        println(ފއޑޔޑދޖޕ.ޝޒއތވވޅޠ)
        println(މޙޗތޅޣޡޙ.ޝޒއތވވޅޠ)
        VglyzwBinding.inflate(layoutInflater)
    }

    private val intentSize by lazy {
        intent.getLongExtra(R.string.ރޏމޏޘ_D.string(), -1)
    }

    var isDeleSuc = false

    private val listPath by lazy {
        intent.getStringArrayExtra(R.string.މޙހރއ_D.string()) ?: arrayOf()
    }

    private var size = 0L

    override val isLightMode = true

    override fun initView() {
        ފރލޛޢށރދ()
    }

    private fun ނތޘޏޑރސގ() {
        ValueAnimator.ofFloat(0f, 360f).run {
            duration = 1000
            repeatMode = ValueAnimator.RESTART
            repeatCount = ValueAnimator.INFINITE
            class ވޝޚމޟޙޝސ(val ޒލޝއގޖޟޟ: String, val ޘޟށޜޢޥޤހ: Int)
            println(ވޝޚމޟޙޝސ("ޝނޝޡތލޘޕ", 8711))
            interpolator = LinearInterpolator()
            fun ޝޝޢދވޑޣޝ(ޏއޡޏޝޥސހ: Int, ކޡޖޣޑޅޙއ: Int): Int {
                fun ނޛރޝހޞހޟ(ޖނޢޏޡޥޕޖ: Int, ޡޥޣޜބޡޠށ: Int): Int {
                    return ޖނޢޏޡޥޕޖ + ޡޥޣޜބޡޠށ
                }
                return ނޛރޝހޞހޟ(ޏއޡޏޝޥސހ, ކޡޖޣޑޅޙއ)
            }
            val ޓރސމދޕޜޑ = ޝޝޢދވޑޣޝ(8204, 1925)
            println(ޓރސމދޕޜޑ)
            addUpdateListener {
                binding.jwjumyq.rotation = it.animatedValue as Float
            }
            val ކއޝޞޤފޒޙ = 5835
            val ޣޣރޛޤޗހޘ = 7134
            val ބޛޢގޟގކޒ = ކއޝޞޤފޒޙ * ޣޣރޛޤޗހޘ * ޣޣރޛޤޗހޘ
            println(ބޛޢގޟގކޒ)
            start()
        }
        ValueAnimator.ofInt(0, 100).run {
            fun <T> ގދޔބދޠމނ(ޓޥޞކޑޙޣޅ: T) {
                println(ޓޥޞކޑޙޣޅ)
            }
            ގދޔބދޠމނ(3302)
            ގދޔބދޠމނ("ދޥޖޛޞޗށޗ")
            duration = Random.nextLong(7000, 8000)
            interpolator = LinearInterpolator()
            addUpdateListener {
                binding.pbhmfjv.text = R.string.ޥޛޖޠތ_D.string((it.animatedValue as Int).toString())
            }
            doOnEnd {
                open class ވޕޟޗށޖޡބ {
                    open fun ޤޥޥރރވޥރ() {}
                }
                class އޓޑޖނރޟޙ : ވޕޟޗށޖޡބ() {
                    override fun ޤޥޥރރވޥރ() {
                        println("ލޕއވޡޅޥޥ")
                    }
                }
                val ޡދވޚޅޕޣޛ = އޓޑޖނރޟޙ()
                println(ޡދވޚޅޕޣޛ)
                Fnpc.showInterstitialAd(this@Fnxq) {
                    fun <T> ޘޓޙނދޠތޕ(ރކޑޞވޕއލ: T) {
                        println(ރކޑޞވޕއލ)
                    }
                    ޘޓޙނދޠތޕ(2367)
                    ޘޓޙނދޠތޕ("ނޝޗޠމތޗޡ")
                    startActivity(Intent(this@Fnxq, Aidw::class.java).putExtra(R.string.ބތހޙޘ_D.string(), Qczw.JUNK_CLEANER).putExtra(R.string.ހޖޒޓބ_D.string(), intentSize))
                    finish()
                }

            }
            start()
        }
        val ޥޔޜގޏޕޠޅ = 3573..3573 + 10
        println(ޥޔޜގޏޕޠޅ.random())
        ValueAnimator.ofFloat(0f, 360f).run {
            duration = 1000
            repeatMode = ValueAnimator.RESTART
            class ޞޡސޏޘޥޟޜ(val ޠތޡޢޜސނޔ: String, val ޖފޛކޗގހޜ: Int)
            println(ޞޡސޏޘޥޟޜ("ލއނޛޥޔވޞ", 847))
            repeatCount = ValueAnimator.INFINITE
            fun ޘހސޗފޑވޡ(ޤކޓބޅޖޥނ: Int, ޞޜޜތކގހޏ: Int): Int {
                return ޤކޓބޅޖޥނ + ޞޜޜތކގހޏ
            }
            println(ޘހސޗފޑވޡ(1001, 1376))
            interpolator = LinearInterpolator()
            class ޤޢބހޅގވޘ(val ޥހޙވޅޤޤއ: String, val މޛޅޗޥޙޜކ: Int)
            println(ޤޢބހޅގވޘ("ޢޙޗޛޔވހލ", 6759))
            addUpdateListener {
                binding.aonpbhs.rotation = it.animatedValue as Float
            }
            Log.d("ކމޔލޑސރޚ", "ކމޔލޑސރޚ")
            start()
        }
        fun ޖށޕތޏޣޤފ(ޜޅނޑތވދޥ: Int, ޙށޤވޥޙފޤ: Int): Int {
            return ޜޅނޑތވދޥ + ޙށޤވޥޙފޤ
        }
        val ޘޣޜޙހނޞފ = ޖށޕތޏޣޤފ(5547, 1294)
        println(ޘޣޜޙހނޞފ)
        ValueAnimator.ofFloat(0f, 360f).run {
            val ޗޣޜޤޠޗޏޞ = 5675
            val ޗއޅބޤޖމނ = 931
            val ފލޠޝޒހވޛ = ޗޣޜޤޠޗޏޞ * ޗއޅބޤޖމނ * ޗއޅބޤޖމނ
            println(ފލޠޝޒހވޛ)
            duration = 1000
            val ޘޛކމޚބޡމ = { މޖޗޡގޑޡލ: String -> println(މޖޗޡގޑޡލ) }
            ޘޛކމޚބޡމ("ޕޠރލލޡތނ!")
            repeatMode = ValueAnimator.RESTART
            repeatCount = ValueAnimator.INFINITE
            class ޣނޜޒލރނޤ<T>(val ށތށޣފޞއޖ: T)
            val ބޘޥލތޖފޑ = ޣނޜޒލރނޤ(2913)
            val ޞދޚމޤޔޡޖ = ޣނޜޒލރނޤ("ޥޤޏޛހޑޙބ")
            println(ބޘޥލތޖފޑ.ށތށޣފޞއޖ)
            println(ޞދޚމޤޔޡޖ.ށތށޣފޞއޖ)
            interpolator = LinearInterpolator()
            addUpdateListener {
                binding.emswfyy.rotation = it.animatedValue as Float
            }
            fun String.ސރޤޑޖތޓޗ(): Boolean {
                return this == this.reversed()
            }
            val ޢޖވށޝނއޜ = "ކހޠމޞޡޕނ"
            val ޏދމސސއޡޒ = ޢޖވށޝނއޜ.ސރޤޑޖތޓޗ()
            println(ޏދމސސއޡޒ)
            start()
        }
        ValueAnimator.ofFloat(0f, 360f).run {
            duration = 1000
            repeatMode = ValueAnimator.RESTART
            repeatCount = ValueAnimator.INFINITE
            val ޠބޠޑޚޑޕޙ = { ޖމޝޥޔޢމފ: String -> println(ޖމޝޥޔޢމފ) }
            ޠބޠޑޚޑޕޙ("ޜވކއޅޡޓޟ!")
            interpolator = LinearInterpolator()
            val ފޑޞޜޙޤޞދ: (Int, Int) -> Int = { ޥޓޤނޞޜކއ, މޖޙޖދޘނޥ -> ޥޓޤނޞޜކއ + މޖޙޖދޘނޥ }
            println(ފޑޞޜޙޤޞދ.invoke(9620, 9903))
            addUpdateListener {
                fun ޣހކނޝނޖޠ(ކޥތޅޠފޞށ: Int, ޒޜޗބޅޤޚއ: Int): Int {
                    return ކޥތޅޠފޞށ + ޒޜޗބޅޤޚއ
                }
                println(ޣހކނޝނޖޠ(1379, 7073))
                binding.xvfvwke.rotation = it.animatedValue as Float
            }
            start()
        }
    }

    private fun ތޖސޖބގޗޏ() {
        BarUtils.setStatusBarColor(this, Color.TRANSPARENT)
        binding.root.updatePadding(top = BarUtils.getStatusBarHeight())
        Npaq.junkSizeClean = Npaq.junkSizeClean+intentSize
        val ޜޑޒޥޙޅޛޏ = 8948
        val ށޅޖހހޝޏޡ = 8133
        val ޜޛތލޞޜވށ = ޜޑޒޥޙޅޛޏ * ށޅޖހހޝޏޡ * ށޅޖހހޝޏޡ
        println(ޜޛތލޞޜވށ)
        MainScope().launch(Dispatchers.IO) {
            try {
                Tgsx.fileList.clear()
                listPath.forEach {
                    val file = File(it)
                    if (Tgsx.deleteFile(file)) {
                        isDeleSuc = true
                    }

                }
            } catch (_: Exception) {
            } finally {

            }
        }
        class ޛނޕލކސޑޜ<T, K>(val ޒޘޣކޤގޕޠ: T, val ރބއބށޓޔޥ: K) {
            init {
                println("މމޒޞޚޓޘހ")
            }
        }
        val ރޚޖފކޠލހ = ޛނޕލކސޑޜ("ޗޓލތޕޝތހ", 1589)
        println(ރޚޖފކޠލހ)
        playAnm()
    }

    private fun playAnm() {
        ހޛޞއއބބޘ()
    }

    private fun ފރލޛޢށރދ() {
        val ޥޠނޠދސޡޢ: (Int, Int) -> Int = { ނވޣޥކޅލޢ, ޥޙޡޙނކޤރ -> ނވޣޥކޅލޢ + ޥޙޡޙނކޤރ }
        println(ޥޠނޠދސޡޢ.invoke(1516, 9270))
        ތޖސޖބގޗޏ()
    }

    private fun ހޛޞއއބބޘ() {
        abstract class ސޝޠޝޥޡށގ {
            abstract fun ޚސޢބޕޓތރ()
        }
        class ޝމހރޠރފޏ : ސޝޠޝޥޡށގ() {
            override fun ޚސޢބޕޓތރ() {
                println("ޢޥޖފހޤޤވ")
            }
        }
        val ޣއޛދފޢޞޛ = ޝމހރޠރފޏ()
        ޣއޛދފޢޞޛ.ޚސޢބޕޓތރ()
        ޙދރޞޛރޔބ()
    }

    private fun ޙދރޞޛރޔބ() {
        ނތޘޏޑރސގ()
    }
}