package importantedto.appliededto.surgeonedto.promiseedto.obtainedto.museumedto.outletedto

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.WillpoweredtoBinding
import importantedto.admireedto.sweptedto.Differenceedto
import importantedto.afteredto.constitutionaledto.Murderedto
import importantedto.appliededto.surgeonedto.promiseedto.Halcyonedto
import importantedto.concreteedto.cameedto.Hateedto.BATTERY_INFO
import importantedto.gallonedto.Transcendedto
import importantedto.maidedto.witnessedto.nationalismedto.Photocopyedto.showExitFunctionDialog
import importantedto.weedto.carpetedto.acresedto.Coachedto
import kotlin.math.abs


class Hardshipedto : Murderedto<WillpoweredtoBinding>() {

    private val TAG = "BatteryActivity"

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

    private lateinit var mBatteryManager: BatteryManager

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

        batteryReceiver = Coachedto {
            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.tycoonedto.text = "${it}mA"
//            }
//        }
//        lifecycleScope.launch(Dispatchers.Main) {
//            averageFlow.collectLatest {
//                binding.scanedto.text = "${it}mA"
//            }
//        }

        Differenceedto.admobMaxShowNativeAd(this, binding.agileedto, 2)
    }

    override fun initListener() {
        super.initListener()
        onBackPressedDispatcher.addCallback {
            showExitFunctionDialog { showAd ->
                if (showAd) {
                    Differenceedto.admobMaxShowInterstitialAd(this@Hardshipedto) {
                        finishToMain()
                    }
                } else {
                    finishToMain()
                }
            }
        }
        binding.bangedto.setOnClickListener {
            onBackPressedDispatcher.onBackPressed()
        }
        binding.spentedto.setOnClickListener {
            startActivity(Intent(this, Halcyonedto::class.java).apply {
                putExtra("from", BATTERY_INFO)
            })
            finish()
        }
    }

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

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

        binding.customeredto.text = Coachedto.technology

        val capacity = Coachedto.mAh.toInt()
        binding.hibernateedto.text = "$capacity mAh"

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

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

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

        binding.allyedto.text = abs(hm.toInt()).toString()
        binding.conventionaledto.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
//
//        Tumbleedto.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 {
//            ""
//        }
//        Tumbleedto.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
//            Tumbleedto.logDebug(TAG, "readFileValue value=$value")
//        } catch (e: Exception) {
//            e.printStackTrace()
//        } finally {
//            br?.close()
//        }
//        return value
//    }

}