package com.base.browserwhite.ui.activity

import android.annotation.SuppressLint
import android.content.Intent
import android.graphics.Color
import android.net.Uri
import android.text.SpannableString
import android.text.Spanned
import android.text.style.UnderlineSpan
import android.view.View
import androidx.lifecycle.lifecycleScope
import com.base.browserwhite.bean.ConstObject.ID_APP_PROCESS
import com.base.browserwhite.bean.ConstObject.ID_JUNK_CLEANER
import com.base.browserwhite.bean.ConstObject.ID_NEWS
import com.base.browserwhite.bean.ConstObject.ID_SCAN_CODE
import com.base.browserwhite.bean.ConstObject.ifAgreePrivacy
import com.base.browserwhite.databinding.ActivitySplashBinding
import com.base.browserwhite.ui.activity.cleanjunk.ScanJunkActivity
import com.base.browserwhite.utils.BarUtils
import com.base.browserwhite.utils.ConfigHelper
import com.base.browserwhite.utils.LogEx
import kotlinx.coroutines.Job
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import kotlin.random.Random

@SuppressLint("CustomSplashScreen")
class SplashActivity : BaseActivity<ActivitySplashBinding>() {

    private val TAG = "SplashActivity"
    private var job: Job? = null
    private val progress = MutableSharedFlow<Int>()
    private val progressFlow: SharedFlow<Int> = progress
    private var oneClickStart: Boolean = false
    private var actionId = -1


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

    override fun initView() {
        BarUtils.setStatusBarLightMode(this, true)
        BarUtils.setStatusBarColor(this, Color.TRANSPARENT)


//        startStayNotification()
//        NotificationUtil.stopNotificationHandler()

        actionId = intent?.extras?.getInt("actionId") ?: -1
//        closeNotification()

        progressCollect()

        if (ifAgreePrivacy) {
//            AdmobMaxHelper.preloadAd(this)
            job = startProgress()
            binding.llStart.visibility = View.GONE
            binding.llProgress.visibility = View.VISIBLE
        } else {
            binding.llStart.visibility = View.VISIBLE
            binding.llProgress.visibility = View.GONE
        }

        val spannableString = SpannableString("Privacy Policy")
        spannableString.setSpan(
            UnderlineSpan(),
            0,
            spannableString.length,
            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
        )
        binding.idTvPrivacyPolicy.text = spannableString

        binding.idTvPrivacyPolicy.setOnClickListener {
            val intent = Intent(
                Intent.ACTION_VIEW,
                Uri.parse(ConfigHelper.privacyPolicy)
            )
            startActivity(intent)
        }
    }

    private fun progressCollect() {
        lifecycleScope.launch {
            progressFlow.collectLatest {
                if (it >= 100) {
                    job?.cancel()
                    jumpNext()
                    this.cancel()
                }
            }
        }
    }

    var jumped: Boolean = false
    private fun jumpNext() {

        if (jumped) {
            return
        }
        jumped = true
        LogEx.logDebug(TAG, "jumpNext actionId=$actionId")

        when (actionId) {
            ID_JUNK_CLEANER -> {
                startActivity(Intent(this, ScanJunkActivity::class.java))
            }

            ID_NEWS -> {

            }

            ID_SCAN_CODE -> {

            }

            ID_APP_PROCESS -> {

            }

            else -> {
                val isHotLaunch = intent?.extras?.getBoolean("isHotLaunch", false) ?: false
                if (!isHotLaunch) {
                    startActivity(Intent(this@SplashActivity, MainActivity::class.java))
                    startActivity(Intent(this@SplashActivity, MainActivity::class.java))
                }
            }
        }
        finish()
        intent?.extras?.clear()
    }

//    private fun closeNotification() {
//        sendBroadcast(Intent(this, CloseNotificationReceiver::class.java).apply {
//            this.action = CloseNotificationReceiver.Action
//            this.putExtra(NotificationId, actionId)
//        })
//    }

    override fun initListener() {

        binding.idTvStart.setOnClickListener {
            if (oneClickStart) {
                return@setOnClickListener
            }
            oneClickStart = true
            ifAgreePrivacy = true
//            (application as MyApplication).initApp(true)
//            AdmobMaxHelper.preloadAd(this)
            binding.llStart.visibility = View.GONE
            binding.llProgress.visibility = View.VISIBLE
            job = startProgress()
        }
    }

    private var processTime = 0L
    private var outTimeAdStart = false
    private fun startProgress() = lifecycleScope.launch {
//        LogEx.logDebug(TAG, "startProgress")
        while (isActive) {
            val value = binding.pb.progress + 2
            binding.pb.setProgress(value, true)
            progress.emit(value)

            val delayTime = 300L
            delay(delayTime)
            processTime += delayTime
            if (processTime >= Random.nextLong(5000, 8000)) {
                if (!outTimeAdStart) {
                    outTimeAdStart = true
                    outTimeAd()
                }
            }
        }
    }


    private fun outTimeAd() {
//        LogEx.logDebug(TAG, "outTimeAd")
//
//        var loaded: Boolean = true
//        AdmobMaxHelper.admobMaxShowOpenAd(this, showBeforeAction = { flag ->
//            LogEx.logDebug(TAG, "showBeforeAction flag=$flag")
//            loaded = flag
//            job?.cancel()
//        }, onHidden = {
//            val sp = AppPreferences.getInstance().getString("splashShowInter", "0").toInt()
//            if (sp == 1 && !loaded) {
//                AdmobMaxHelper.admobMaxShowInterstitialAd(this, isLoading = false) {
//                    binding.pb.progress = 100
//                    jumpNext()
//                }
//            } else {
        binding.pb.progress = 100
        jumpNext()
//            }
//
//        })
    }

    override fun onResume() {
        super.onResume()
        LogEx.logDebug(TAG, "onResume")
        if (ifAgreePrivacy && job?.isActive == false) {
            job = startProgress()
        }
    }

    override fun onPause() {
        super.onPause()
        job?.cancel()
        LogEx.logDebug(TAG, "onPause")
    }


}