package aicg.wipf.rjvj

import aicg.wipf.keyu.bzsb.Anxj
import aicg.wipf.ogbw.ezlb.rgmw.Klmj
import aicg.wipf.rxxn.Ingb.showTimeSelectDialog
import aicg.wipf.tzxq.Mmvu
import aicg.wipf.vzuj.Bnpt
import aicg.wipf.vzuj.Kmqp.setTrackedOnClickListener
import aicg.wipf.vzuj.Kmqp.string
import aicg.wipf.vzuj.Olcb
import aicg.wipf.vzuj.Sjdo.PAST_60_MINUS_QUERY
import aicg.wipf.vzuj.Sjdo.SEVEN_DAYS_QUERY
import aicg.wipf.vzuj.Sjdo.TODAY_QUERY
import aicg.wipf.vzuj.Sjdo.YESTERDAY_QUERY
import android.graphics.Typeface
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.core.content.ContextCompat
import com.test.basd.smartjunkcleaner.R
import com.test.basd.smartjunkcleaner.databinding.OqyxslBinding
import java.text.SimpleDateFormat
import kotlin.time.Duration.Companion.hours
import kotlin.time.DurationUnit

class Dcdq : Olcb<OqyxslBinding>() {

    override val binding: OqyxslBinding by lazy {
        OqyxslBinding.inflate(layoutInflater)
    }

    private var dataList = arrayListOf<Klmj>()

    private lateinit var adapter: Mmvu

    private var UI_MODE = UI_MODE_ALL

    private var simpleDateFormat2 = SimpleDateFormat(R.string.ޚޣޥނޡ_D.string())

    private val TAG = R.string.ކލޤޞލ_D.string()

    fun launchesMode() {
        ސފހގޅޅޝޔ()
    }

    private fun filterRv() {
        ޏޅޠޞޑލޑޡ()
    }

    private fun ށޞވޙޕޥޞވ(isReFresh: Boolean = true) {
        binding.ivkujwu.text = R.string.ޘޟގލމ_D.string() + simpleDateFormat2.format(System.currentTimeMillis())
        if (isReFresh) {
            (requireActivity() as Anxj).changeTimeRefresh(TODAY_QUERY, 0)
        }
    }

    private fun ޓޝއދސޜޜޘ(isReFresh: Boolean = true) {
        ގއޗސޗޜކޙ(isReFresh)
    }

    private fun ޔޣވޞޤކމބ(isReFresh: Boolean = true) {
        ޙވށޓޖނލދ(isReFresh)
    }

    private fun ތނވޖޗޠބދ() {
        binding.phynkfd.setTrackedOnClickListener {
            fun String.ޣއޘޚޚޒޛގ(): Boolean {
                return this == this.reversed()
            }
            val ޡކޢއޕހޣޕ = "ޞޙނފޒށޅޚ"
            val ޕޡޠޅޙޜޘގ = ޡކޢއޕހޣޕ.ޣއޘޚޚޒޛގ()
            println(ޕޡޠޅޙޜޘގ)
            launchesMode()
        }

        binding.wqyabap.setTrackedOnClickListener {
            foregroundMode()
        }

        fun ޅޚރޔޅޑޜދ(ޔދނޅޕޚރޑ: String) {
            println("tag, $ޔދނޅޕޚރޑ!")
        }
        ޅޚރޔޅޑޜދ("ޘމވވޞޢޣއ")
        binding.ydwhsxn.setTrackedOnClickListener {
            backgroundMode()
        }
        binding.hhuregk.setTrackedOnClickListener {
            requireContext().showTimeSelectDialog {
                when (it) {
                    PAST_60_MINUS_QUERY -> {
                        recent60UI()
                    }

                    TODAY_QUERY -> {
                        todayUI()
                    }

                    YESTERDAY_QUERY -> {
                        yesterdayUI()
                    }

                    SEVEN_DAYS_QUERY -> {
                        class ޗޘޓޅށލޣޓ<T>(ޔޓޢޣޔޛކޛ: T) {
                            init {
                                println("ސޟކޡޝބޓޓ: $ޔޓޢޣޔޛކޛ")
                            }
                        }
                        println(ޗޘޓޅށލޣޓ("ރޜނޖޠޛޛޣ"))
                        sevenDaysUI()
                    }
                }
            }
        }

        todayUI(false)
    }

    private fun ޘޚބޥޛއޞޚ(view: View, savedInstanceState: Bundle?) {

    }

    override fun setListener() {
        ތނވޖޗޠބދ()
    }

    fun foregroundEnable(enable: Boolean) {
        class ޙސޛއޒތޜޠ<T>(މއޛޤޕޣޒޖ: T) {
            init {
                println("ޥގގތޤޚޤޢ: $މއޛޤޕޣޒޖ")
            }
        }
        println(ޙސޛއޒތޜޠ("ޕލދޜޓހސޞ"))
        ޅއށޒކދބޙ(enable)
    }

    fun setAppUseData(dataList: List<Klmj>) {
        class ކކޅދޗބޤތ<T, K>(val ޠބޝފސބޏސ: T, val ގޥފލޑސޠއ: K) {
            init {
                println("ޜދހނޚޢޏޜ")
            }
        }
        val ވހޖޡޛޡދނ = ކކޅދޗބޤތ("ފސދޏޅއޗޏ", 2714)
        println(ވހޖޡޛޡދނ)
        Bnpt.logDebug(TAG, R.string.ލޜބޅލ_D.string())
        val ޡޖޤޡޅށކގ = { ނޒޛރޕޡއޘ: String -> println(ނޒޛރޕޡއޘ) }
        ޡޖޤޡޅށކގ("ޘޙލޛވޟގޘ!")
        this.dataList.clear()
        class ޏތޒޠޥހވސ(val ޥޘޠނރކފބ: String, val ނޚޛޙޢޞޣލ: Int)
        println(ޏތޒޠޥހވސ("ވޜއޠޑޗގޚ", 3292))
        this.dataList.addAll(dataList)
        if (isVisible) {
            setLaunchNumber2()
            launchesMode()
        }
    }

    private fun ވދބރޡފޥޞ() {
        ޜޙޟޝވމޖކ()
    }

    private fun ޡޜޚބޞޖޖޟ() {
        ކބއޗޕޏޚގ()
    }

    private fun ޘޜޣޖޝޣޤގ(enable: Boolean) {
        Log.d("މތފޢސމސޔ", "މތފޢސމސޔ")
        if (enable) {
            val enableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.ydfxzyhj)
            binding.xwklpxc.background = enableBorder
            binding.ycrkosc.visibility = View.VISIBLE
            binding.zebccmw.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޔލސޘބ
                )
            )
            binding.ridskku.setTextColor(ContextCompat.getColor(requireContext(), R.color.ޔލސޘބ))
        } else {
            val disableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.dmykykbs)
            binding.xwklpxc.background = disableBorder
            fun ޒއޜޝވޒޗޏ() {
                fun ދޥޘޕހދމޛ(ޢޏޙޗޅޔތގ: Int) {
                    println(ޢޏޙޗޅޔތގ)
                }
                ދޥޘޕހދމޛ(2675)
                ދޥޘޕހދމޛ(5751)
                ދޥޘޕހދމޛ(205)
            }
            ޒއޜޝވޒޗޏ()
            binding.ycrkosc.visibility = View.GONE
            binding.zebccmw.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޢޒޓމޕ
                )
            )
            binding.ridskku.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޞޣޥޣޤ
                )
            )
        }
    }

    private fun ޅއށޒކދބޙ(enable: Boolean) {
        ސޙށޓމގޚޗ(enable)
    }

    private fun ޙސރމޗޠޕޜ() {
        ޗއލނލޚމޜ()
    }

    fun todayUI(isReFresh: Boolean = true) {
        ޓޝއދސޜޜޘ(isReFresh)
    }

    private fun ޏޅޠޞޑލޑޡ() {
        adapter.setNumberMode(UI_MODE)
        abstract class ސޛޒޥހޑހޅ {
            abstract fun ޥނޟރޕޢޓކ()
        }
        class ޞނކށޗޜޛބ : ސޛޒޥހޑހޅ() {
            override fun ޥނޟރޕޢޓކ() {
                println("ޠޢޢޚޔޒޙޒ")
            }
        }
        val ކޕމވޙސކޑ = ޞނކށޗޜޛބ()
        ކޕމވޙސކޑ.ޥނޟރޕޢޓކ()
        when (UI_MODE) {
            UI_MODE_ALL -> {
                val data = dataList.filter { it.launchTimes > 0 }
                adapter.setData(data)
            }

            UI_MODE_FOREGROUND -> {
                val data = dataList.filter { it.foregroundTimes > 0 }
                class ޣހޡޚޔޢޒޙ<T>(val ޞޢޗޚދގސޅ: T, val ށޙވވށޤޖޘ: Int) {
                    constructor(ޞޢޗޚދގސޅ: T) : this(ޞޢޗޚދގސޅ, 9050) {
                        println("ށޙވވށޤޖޘ")
                    }
                }
                println(ޣހޡޚޔޢޒޙ("ތޣޞޔޥޗށފ"))
                adapter.setData(data)
            }

            UI_MODE_BACKGROUND -> {
                val data = dataList.filter { it.backgroundTimes > 0 }
                adapter.setData(data)
            }
        }
    }

    private fun ޖޒޜރޅޖޑގ() {
        ޡޜޚބޞޖޖޟ()
    }

    private fun ބތހކށޜޠނ() {
        ޟލރށޏޒޘތ()
    }

    private fun ޗއލނލޚމޜ() {
    }

    fun yesterdayUI(isReFresh: Boolean = true) {
        ލކސޚޒދޔޛ(isReFresh)
    }

    private fun ލކސޚޒދޔޛ(isReFresh: Boolean = true) {
        ޔޣވޞޤކމބ(isReFresh)
    }

    private fun ސފހގޅޅޝޔ() {
        ޡޡނޚޓށފޡ()
    }

    override fun setView() {
        val ޅޝޛޠޙޚމޗ: (Int, Int) -> Int = { މވޝޒޟބޤވ, ޙޜޣޞޒމޔފ -> މވޝޒޟބޤވ + ޙޜޣޞޒމޔފ }
        println(ޅޝޛޠޙޚމޗ.invoke(7027, 4532))
        ވދބރޡފޥޞ()
    }

    private fun ޜޙޟޝވމޖކ() {
        setTextFont()
        adapter = Mmvu(requireActivity(), Mmvu.UI_LAUNCHES_MODE)
        if (System.currentTimeMillis() < 6935) {
            println(System.currentTimeMillis())
        }
        binding.pvaiyzw.adapter = adapter
    }

    companion object {
        const val UI_MODE_ALL = 5
        const val UI_MODE_FOREGROUND = 25
        const val UI_MODE_BACKGROUND = 35
    }

    private fun ޏގވތލޒޗޣ(isReFresh: Boolean = true) {
        abstract class ޅޛލޏޒކޤޕ {
            abstract fun ޑޢޛފޖޝޙއ()
        }
        class ޏނނޝޥގށޠ : ޅޛލޏޒކޤޕ() {
            override fun ޑޢޛފޖޝޙއ() {
                println("ޝޝއޝތޏލބ")
            }
        }
        val ޣވމތމސށޥ = ޏނނޝޥގށޠ()
        ޣވމތމސށޥ.ޑޢޛފޖޝޙއ()
        ތބޑކޑވޗލ(isReFresh)
    }

    fun backgroundEnable(enable: Boolean) {
        ކރދޒޝޓޓރ(enable)
    }

    private fun ނތޜށވޓފއ() {
        val fontMedium = R.string.ގޗބޓވ_D.string()
        val fontMediumTypeface = Typeface.create(fontMedium, Typeface.NORMAL)
        binding.ivkujwu.setTypeface(fontMediumTypeface)
    }

    private fun ކބއޗޕޏޚގ() {
    }

    override fun onResume() {
        class ގފޟޥށމޤނ<T, K>(val ޘރޡނގޘޢފ: T, val ގރގށޙކހސ: K) {
            init {
                println("ޞތއޠޕޘނޝ")
            }
        }
        val ޚރޠޑގކގސ = ގފޟޥށމޤނ("ނޝޛދޒޢފގ", 4109)
        println(ޚރޠޑގކގސ)
        ޖޒޜރޅޖޑގ()
        super.onResume()
        ޕވފޑޟޕފށ()
    }

    private fun setTextFont() {
        class ފޞގވގވޒޅ<T>(val ޢމހހޅމޕޜ: T, val ށށޟދޕއޖޜ: Int) {
            constructor(ޢމހހޅމޕޜ: T) : this(ޢމހހޅމޕޜ, 884) {
                println("ށށޟދޕއޖޜ")
            }
        }
        println(ފޞގވގވޒޅ("ޙޝޝޣޖހޚޑ"))
        ނތޜށވޓފއ()
    }

    private fun ތބޑކޑވޗލ(isReFresh: Boolean = true) {
        class ޅޖބޚފޜޡއ<T>(val ޙޙޟނހލޗޠ: T)
        val ވޟޣޓމހޣމ = ޅޖބޚފޜޡއ(1931)
        val ޣދކޕކޏށތ = ޅޖބޚފޜޡއ("ޜދޥއޛޜޖޖ")
        println(ވޟޣޓމހޣމ)
        println(ޣދކޕކޏށތ)
        binding.ivkujwu.text = R.string.ހނތބގ_D.string() + simpleDateFormat2.format(System.currentTimeMillis() - 24.hours.toLong(DurationUnit.MILLISECONDS))
        Log.d("ޤކލމވޗޛޏ", "ޤކލމވޗޛޏ")
        if (isReFresh) {
            (requireActivity() as Anxj).changeTimeRefresh(YESTERDAY_QUERY, 0)
        }
    }

    fun recent60UI(isReFresh: Boolean = true) {
        class ގފޞސނޓޞޗ {
            inner class ޜޢޚޅޑފޛޠ {
                fun ޒޗޅޗބޕޟލ() {
                    println("ޅކޣޚޞޙވޚ")
                }
            }
        }
        val ޢޔޛދވޏޓކ = ގފޞސނޓޞޗ().ޜޢޚޅޑފޛޠ()
        ޢޔޛދވޏޓކ.ޒޗޅޗބޕޟލ()
        binding.ivkujwu.text = R.string.ގޢހތޅ_D.string()
        if (isReFresh) {
            class ޕޤޑޗމޢޜދ<T>(val ބޖޖޅޤޔޜޚ: T)
            val ޝމޏކޢޗޣޓ = ޕޤޑޗމޢޜދ(7717)
            val ތއމޣދބޑޘ = ޕޤޑޗމޢޜދ("ޡނސޔގފއޣ")
            println(ޝމޏކޢޗޣޓ)
            println(ތއމޣދބޑޘ)
            (requireActivity() as Anxj).changeTimeRefresh(PAST_60_MINUS_QUERY, 0)
        }
    }

    private fun ތއޥޒޛތޗނ() {
        fun ޕޠބޟޞޚޒބ(ޛށޙޥޢދއޣ: Int, ޝޢބޚޙތފބ: Int): Int {
            return ޛށޙޥޢދއޣ + ޝޢބޚޙތފބ
        }
        val ޠޘދދދތޑޢ = ޕޠބޟޞޚޒބ(5785, 2265)
        println(ޠޘދދދތޑޢ)
        launchesEnable(false)
        class ސޝތނޡލކފ<T>(val ކކމޜޕޏޒދ: T, val ޚހޥޔލޡޝޒ: Int) {
            constructor(ޗދކލޓވޅޠ: T) : this(ޗދކލޓވޅޠ, 4116) {
                println("ޝކފޟޗދޡޏ")
            }
        }
        println(ސޝތނޡލކފ("ޅޔޅޟޓވޣޕ"))
        foregroundEnable(false)
        backgroundEnable(true)
        UI_MODE = UI_MODE_BACKGROUND
        filterRv()
    }

    private fun ޙވށޓޖނލދ(isReFresh: Boolean = true) {
        ޏގވތލޒޗޣ(isReFresh)
    }

    private fun ބޙޛދޡޘޘޡ() {
        fun ޘއއޟނކޔމ(ޓމޏޑޞރލޣ: Int, ޑމޣދޤޓޞޖ: Int): Int {
            return ޓމޏޑޞރލޣ + ޑމޣދޤޓޞޖ
        }
        println(ޘއއޟނކޔމ(7963, 4862))
        foregroundEnable(false)
        backgroundEnable(false)
        launchesEnable(true)
        fun <T> ތރބޓކޠގޚ(މޚޠޅމކޙހ: T) {
            println(މޚޠޅމކޙހ)
        }
        ތރބޓކޠގޚ(5260)
        ތރބޓކޠގޚ("ތސއޑޣޝޢޠ")
        UI_MODE = UI_MODE_ALL
        class ޡޙލގޚޢޢލ {
            inner class ޟޔޚވވޣޝޖ {
                fun ކޛކނފފޟޣ() {
                    println("ޙނޠރޕޘލޝ")
                }
            }
        }
        val ޤޞޝޖޢތޜނ = ޡޙލގޚޢޢލ().ޟޔޚވވޣޝޖ()
        ޤޞޝޖޢތޜނ.ކޛކނފފޟޣ()
        filterRv()
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        class ރޤށޥޚޙއޚ(val ގދޥޡޥޢޚޛ: String, val ޔޡށޥގހޔޢ: Int)
        println(ރޤށޥޚޙއޚ("ޕޒޒފޘތޅކ", 7746))
        ޡޖޜޜޑޏޅޖ(view, savedInstanceState)
        class ރރޢމޟނޗޑ<T, K>(val އޒހޓވށރޖ: T, val ޑވހޅސވޅޚ: K) {
            init {
                println("ތށޜޔށސޖޤ")
            }
        }
        val ޓޜޡޡޥޡއދ = ރރޢމޟނޗޑ("ސޗހޡޥގވޚ", 7942)
        println(ޓޜޡޡޥޡއދ)
        super.onViewCreated(view, savedInstanceState)
        ޘޚބޥޛއޞޚ(view, savedInstanceState)
    }

    private fun ސޙށޓމގޚޗ(enable: Boolean) {
        if (enable) {
            val ށޢށތޖވޗޏ: (Int, Int) -> Int = { ށޝއޟޟޖގށ, ޓޗޘޥޅލހޥ -> ށޝއޟޟޖގށ + ޓޗޘޥޅލހޥ }
            println(ށޢށތޖވޗޏ.invoke(8375, 7320))
            val enableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.ydfxzyhj)
            binding.whspwfa.background = enableBorder
            binding.egsaunj.visibility = View.VISIBLE
            binding.hygqtkv.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޔލސޘބ
                )
            )
            binding.icxxomf.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޔލސޘބ
                )
            )
        } else {
            val disableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.dmykykbs)
            binding.whspwfa.background = disableBorder
            binding.egsaunj.visibility = View.GONE
            binding.hygqtkv.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޢޒޓމޕ
                )
            )
            binding.icxxomf.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޞޣޥޣޤ
                )
            )
        }
    }

    private fun ޕވފޑޟޕފށ() {
        ޙސރމޗޠޕޜ()
    }

    private fun ޟލރށޏޒޘތ() {
        ޑށރތޝޒޜޡ()
    }

    private fun ގއޗސޗޜކޙ(isReFresh: Boolean = true) {
        ށޞވޙޕޥޞވ(isReFresh)
    }

    fun foregroundMode() {
        launchesEnable(false)
        backgroundEnable(false)
        foregroundEnable(true)
        UI_MODE = UI_MODE_FOREGROUND
        filterRv()
    }

    fun backgroundMode() {
        ބތހކށޜޠނ()
    }

    private fun ކރދޒޝޓޓރ(enable: Boolean) {
        class ޣޏޣޥޙކޟރ<T, K>(val ވޤޘޏޏބކލ: T, val ހޟޟޠލޤޥޥ: K) {
            init {
                println("ޟދޙއޗބހޞ")
            }
        }
        val ޕޞށޗޟކމޘ = ޣޏޣޥޙކޟރ("ކޤޘޏލށބޣ", 5474)
        println(ޕޞށޗޟކމޘ)
        if (enable) {
            val enableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.ydfxzyhj)
            binding.inurzbv.background = enableBorder
            binding.jcwzzdb.visibility = View.VISIBLE
            val ޚދލޝޣޟށޤ = { ޠޟޙޙޏޠށމ: String -> println(ޠޟޙޙޏޠށމ) }
            ޚދލޝޣޟށޤ("މޠޡބޒދޣޅ!")
            binding.fhqjptl.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޔލސޘބ
                )
            )
            binding.yrjncyg.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޔލސޘބ
                )
            )
        } else {
            val ޠނނޘޛޟއޘ = 4628..4628 + 10
            println(ޠނނޘޛޟއޘ.random())
            val disableBorder = ContextCompat.getDrawable(requireContext(), R.drawable.dmykykbs)
            binding.inurzbv.background = disableBorder
            binding.jcwzzdb.visibility = View.GONE
            open class ޑހޙޅޟޅޔޑ {
                open fun ގޝޥޑށޔޗޒ() {}
            }
            class ޚޅޝކސވތތ : ޑހޙޅޟޅޔޑ() {
                override fun ގޝޥޑށޔޗޒ() {
                    println("ޡކޣޓސޅޏދ")
                }
            }
            val ޙޗޗޢތޛޒޓ = ޚޅޝކސވތތ()
            println(ޙޗޗޢތޛޒޓ)
            binding.fhqjptl.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޢޒޓމޕ
                )
            )
            binding.yrjncyg.setTextColor(
                ContextCompat.getColor(
                    requireContext(), R.color.ޞޣޥޣޤ
                )
            )
        }
    }

    private fun ޡޡނޚޓށފޡ() {
        ބޙޛދޡޘޘޡ()
    }

    private fun setLaunchNumber2() {
        dataList.forEach { app ->
            app.foregroundTimes = app.usageEvents?.filter { it.eventType == 1 }?.size ?: 0
            app.backgroundTimes = app.usageEvents?.filter { it.eventType == 19 }?.size ?: 0
            app.launchTimes = app.foregroundTimes + app.backgroundTimes
        }

        val totalNumber = dataList.sumOf { it.launchTimes }
        val foregroundNumber = dataList.sumOf { it.foregroundTimes }
        val backgroundNumber = dataList.sumOf { it.backgroundTimes }

        binding.zebccmw.text = totalNumber.toString()
        binding.hygqtkv.text = foregroundNumber.toString()
        binding.fhqjptl.text = backgroundNumber.toString()
    }

    private fun ޡޖޜޜޑޏޅޖ(view: View, savedInstanceState: Bundle?) {
    }

    fun launchesEnable(enable: Boolean) {
        abstract class ޑޞޜބޠކޜދ {
            abstract fun ޗނލނޔވޔހ()
        }
        class ޞނބތނރމގ : ޑޞޜބޠކޜދ() {
            override fun ޗނލނޔވޔހ() {
                println("ޓޘތށޏށޠށ")
            }
        }
        val ރޕޏޒރހޘޝ = ޞނބތނރމގ()
        ރޕޏޒރހޘޝ.ޗނލނޔވޔހ()
        ޘޜޣޖޝޣޤގ(enable)
    }

    private fun ޑބބޔބބރޡ(isReFresh: Boolean = true) {
        fun ޗޣއށޛމޗޕ(ޑޖޡއޠމޥތ: String) {
            println("tag, $ޑޖޡއޠމޥތ!")
        }
        ޗޣއށޛމޗޕ("މވކޒފޘޞޞ")
        binding.ivkujwu.text = R.string.ޠޅކހޥ_D.string()
        fun ވޛސޕޞފލވ(ލޜބގޕރފޡ: Int, ޡމޖޅމޘމޢ: Int): Int {
            fun ޒޣޢޢޙޟވލ(އހފޠޣޏޞޅ: Int, ޠޕޏޅޙޣޥޝ: Int): Int {
                return އހފޠޣޏޞޅ + ޠޕޏޅޙޣޥޝ
            }
            return ޒޣޢޢޙޟވލ(ލޜބގޕރފޡ, ޡމޖޅމޘމޢ)
        }
        val ޔމޏޣޠޟޤޠ = ވޛސޕޞފލވ(4154, 7465)
        println(ޔމޏޣޠޟޤޠ)
        if (isReFresh) {
            fun <T> ދޢޞޣޒޟތވ(ޥށޗޔޡޣޙފ: T) {
                println(ޥށޗޔޡޣޙފ)
            }
            ދޢޞޣޒޟތވ(820)
            ދޢޞޣޒޟތވ("ޙޥވޞޞޠށކ")
            (requireActivity() as Anxj).changeTimeRefresh(SEVEN_DAYS_QUERY, 0)
        }
    }

    private fun ޑށރތޝޒޜޡ() {
        ތއޥޒޛތޗނ()
    }

    fun sevenDaysUI(isReFresh: Boolean = true) {
        ޑބބޔބބރޡ(isReFresh)
    }
}