package rallyedto.finishedto.climateedto.depressionedto.dustedto

import android.annotation.SuppressLint
import android.content.Intent
import android.content.IntentFilter
import android.graphics.Color
import android.os.BatteryManager
import androidx.activity.addCallback
import androidx.core.view.updatePadding
import com.base.datarecovery.databinding.VerbedtoBinding
import rallyedto.battleedto.acresedto.Lemonedto
import rallyedto.directoredto.wordedto.cameedto.Hospitalityedto
import rallyedto.farewelledto.Technologyedto.showExitFunctionDialog
import rallyedto.finishedto.Screamedto
import rallyedto.policeedto.huntedto.Snuggleedto.BATTERY_INFO
import rallyedto.sunedto.tumouredto.majorityedto.loseedto.Togetheredto
import rallyedto.talledto.blewedto.Islandedto
import kotlin.math.abs


class Workedto : Lemonedto<VerbedtoBinding>() {

    private val TAG = "BatteryActivity"

    override val binding: VerbedtoBinding by lazy {
        VerbedtoBinding.inflate(layoutInflater)
    }
    private lateinit var batteryReceiver: Hospitalityedto

    private lateinit var mBatteryManager: BatteryManager

    @SuppressLint("SetTextI18n")
    override fun initView() {
        Islandedto.setStatusBarLightMode(this, true)
        Islandedto.setStatusBarColor(this, Color.parseColor("#FAFAFA"))
        binding.root.updatePadding(top = Islandedto.getStatusBarHeight())

        batteryReceiver = Hospitalityedto {
            updateUi()
        }
        registerReceiver(batteryReceiver, IntentFilter().apply {
            addAction("android.intent.action.BATTERY_CHANGED")
        })

        mBatteryManager = getSystemService(BATTERY_SERVICE) as BatteryManager

//        getAverageCurrent()
//
//        lifecycleScope.launch(Dispatchers.Main) {
//            currentFlow.collectLatest {
//                binding.fundedto.text = "${it}mA"
//            }
//        }
//        lifecycleScope.launch(Dispatchers.Main) {
//            averageFlow.collectLatest {
//                binding.sipedto.text = "${it}mA"
//            }
//        }

        Togetheredto.showNativeAd(this, binding.disappointedto)
    }

    override fun initListener() {
        super.initListener()
        onBackPressedDispatcher.addCallback {
            showExitFunctionDialog {
                admobMaxShowInterstitialAd(isShow = Togetheredto.isShowAdBackInter()) {
                    finishToMain()
                }
            }
        }
        binding.unfortunateedto.setOnClickListener {
            onBackPressedDispatcher.onBackPressed()
        }
        binding.possessionedto.setOnClickListener {
            admobMaxShowInterstitialAd(true) {
                startActivity(Intent(this, Screamedto::class.java).apply {
                    putExtra("from", BATTERY_INFO)
                })
                finish()
            }
        }
    }

    @SuppressLint("SetTextI18n")
    private fun updateUi() {
        val temperature = Hospitalityedto.temperature / 10f
        binding.exploitedto.text = format(temperature) + " °C"

        binding.methodedto.text = "${format((Hospitalityedto.voltage / 1000f))} mV"

        binding.recordingedto.text = Hospitalityedto.technology

        val capacity = Hospitalityedto.mAh.toInt()
        binding.loopedto.text = "$capacity mAh"

        val currentNow = mBatteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CURRENT_NOW)
        binding.fundedto.text = "${getFirstThreeDigits(currentNow * 100)} mA"

        val currentAverage: Int =
            mBatteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CURRENT_AVERAGE)
        binding.sipedto.text = "${getFirstThreeDigits(currentAverage * 100)} mA"

        val hm = (capacity.toFloat() / getFirstThreeDigits(currentNow * 100).toFloat())

        binding.timeedto.text = abs(hm.toInt()).toString()
        binding.stopedto.text = abs(((hm - hm.toInt()) * 60).toInt()).toString()
    }

    private fun getFirstThreeDigits(number: Int): String {
        if (number == 0) {
            return "0"
        }
        return number.toString().take(3)
    }

    private fun format(float: Float): String {
        return "%.1f".format(float)
    }

    override fun onDestroy() {
        super.onDestroy()
        unregisterReceiver(batteryReceiver)
    }


//    @SuppressLint("PrivateApi")
//    fun getBatteryFilePath(): String {
//        val systemProperties = Class.forName("android.os.SystemProperties")
//        val getMethod = systemProperties.getDeclaredMethod("get", String::class.java)
//        val platName = getMethod.invoke(null, "ro.hardware") as String
//
//        Musicaledto.logDebug(TAG, "platName=$platName")
//        val filePath: String = if (platName.startsWith("mt") || platName.startsWith("MT")) {
//            "/sys/class/power_supply/battery/device/FG_Battery_CurrentConsumption"
//            // MTK平台该值不区分充放电，都为负数
//        } else if (platName.startsWith("qcom")) {
//            "/sys/class/power_supply/battery/current_now"
//        } else if (platName.startsWith("exynos"))
//            "/sys/class/power_supply/battery/BatteryAverageCurrent"
//        else {
//            ""
//        }
//        Musicaledto.logDebug(TAG, "filePath=$filePath")
//        return filePath
//    }


//    var mAverageFlow = MutableSharedFlow<Float>()
//    val averageFlow: SharedFlow<Float> = mAverageFlow
//
//    var mCurrentFlow = MutableSharedFlow<Int>()
//    var currentFlow: SharedFlow<Int> = mCurrentFlow


//    private fun getAverageCurrent(filePath: String = getBatteryFilePath()) {
//        var sum = 0
//        var loopCount = 0
//        lifecycleScope.launch(Dispatchers.IO) {
//            while (isActive) {
//                val currentValue = readFileValue(filePath)
//                mCurrentFlow.emit(currentValue)
//                sum += currentValue
//                loopCount++
//                val average = sum / loopCount.toFloat()
//                mAverageFlow.emit(average)
//                delay(150)
//            }
//        }
//    }


//    private fun readFileValue(filePath: String): Int {
//        var value = 0
//        var br: BufferedReader? = null
//        try {
//            br = BufferedReader(FileReader(filePath))
//            val line = br.readLine()
//            value = line?.toInt() ?: 0
//            Musicaledto.logDebug(TAG, "readFileValue value=$value")
//        } catch (e: Exception) {
//            e.printStackTrace()
//        } finally {
//            br?.close()
//        }
//        return value
//    }

}