package com.develop.foodcooking

import android.annotation.SuppressLint
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.PowerManager
import android.provider.Settings
import com.blankj.utilcode.util.AppUtils
import com.blankj.utilcode.util.PathUtils
import com.blankj.utilcode.util.ResourceUtils
import com.blankj.utilcode.util.Utils
import com.develop.base.app.BaseApp
import com.develop.base.util.MMkvUtils
import com.develop.common.data_repo.FoodDataProvider
import com.develop.common.data_repo.net.Api
import com.develop.common.data_repo.net.converter.SerializationConverter
import com.develop.common.data_repo.net.interceptor.FoodRequestInterceptor
import com.develop.common.food_sdk.GlobalDevEvent
import com.develop.common.food_sdk.SerialPortUtils
import com.develop.common.utils.compat.CategoryTabViewLayoutCompat
import com.develop.common.utils.compat.ClassicsFooterCompat
import com.develop.common.utils.compat.FoodContentViewCompat
import com.develop.common.utils.compat.RecyclerViewCompat
import com.develop.common.utils.compat.ShapeableImageViewCompat
import com.develop.common.utils.compat.SmartRefreshLayoutCompat
import com.develop.common.utils.compat.StartViewCompat
import com.drake.net.convert.NetConverter
import com.drake.net.interceptor.RequestInterceptor
import com.drake.net.interfaces.NetErrorHandler
import com.kuyuntech.cofarcooking.device.sdk.constant.core.DevStatus
import com.kuyuntech.cofarcooking.device.sdk.eventbus.event.DevStatusEvent
import com.kuyuntech.cofarcooking.device.sdk.util.core.CofarSDK
import org.alee.component.skin.compat.ConstraintLayoutCompat
import org.alee.component.skin.page.WindowManager
import org.alee.component.skin.service.Config
import org.alee.component.skin.service.IOptionFactory
import org.alee.component.skin.service.IThemeSkinOption
import org.greenrobot.eventbus.Subscribe
import java.io.File


class FoodCookingApp : BaseApp() {
    companion object {
        init {
            Config.getInstance().skinMode = Config.SkinMode.REPLACE_ALL
            Config.getInstance().performanceMode = Config.PerformanceMode.EXPERIENCE_FIRST
            ConstraintLayoutCompat.init()
            RecyclerViewCompat.init()
            SmartRefreshLayoutCompat.init()
            ShapeableImageViewCompat.init()
            StartViewCompat.init()
        }
    }

    var mWakeLock: PowerManager.WakeLock? = null
    private lateinit var pm: PowerManager
    var minute = 0
    override fun onCreate() {
        super.onCreate()
        ResourceUtils.copyFileFromAssets(
            ASSETS_NIGHT_SKIN_PACK,
            SKIN_PACK_PATH + NIGHT_SKIN_PACK_NAME
        )
        WindowManager.getInstance().init(this, OptionFactory())
        SerialPortUtils.init()
        CofarSDK.register(this)
        CofarSDK.stopNative()

//        val powerManager = getSystemService(POWER_SERVICE) as PowerManager
//        val wakeLock: PowerManager.WakeLock =
//            powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "motionDetection:keepAwake")
//        wakeLock.acquire()
        pm = getSystemService(POWER_SERVICE) as PowerManager
        minute = MMkvUtils.getInt("ScreenSaver")
        if (minute == 0) {
            minute = 3
        }
        Settings.System.putInt(
            contentResolver,
            Settings.System.SCREEN_OFF_TIMEOUT,
            (1000 * 60 * minute).toInt()
        )
        val uri: Uri = Settings.System
            .getUriFor(Settings.System.SCREEN_OFF_TIMEOUT)
        contentResolver.notifyChange(uri, null)
    }

    override fun createHostUrl(): String {
        return Api.HOST
    }

    override fun createRequestInterceptor(): RequestInterceptor {
        return FoodRequestInterceptor()
    }

    override fun createConverter(): NetConverter {
        return SerializationConverter()
    }

    override fun createErrorHandle(): NetErrorHandler {
        return NetErrorHandler.DEFAULT
    }

    override fun attachBaseContext(base: Context?) {
        super.attachBaseContext(base)
        FoodDataProvider.prepareData(this)
    }


    override fun onTerminate() {
        super.onTerminate()
        SerialPortUtils.destroy()
        CofarSDK.unregister(this)
    }

    @SuppressLint("InvalidWakeLockTag")
    @Subscribe
    @Synchronized
    fun globalCoverEvent(event: DevStatusEvent) {
        val devInfo = event.devInfo;
        val pm = getSystemService(POWER_SERVICE) as PowerManager
        if (devInfo.status == DevStatus.RUNNING.toInt() || devInfo.isWeightStatus) {
            if (mWakeLock == null) {
                mWakeLock = pm.newWakeLock(
                    PowerManager.SCREEN_BRIGHT_WAKE_LOCK or PowerManager.ON_AFTER_RELEASE or PowerManager.ACQUIRE_CAUSES_WAKEUP,
                    "tag"
                );
                mWakeLock?.setReferenceCounted(false);
                mWakeLock?.acquire()
            }
        } else if (devInfo.status != DevStatus.RUNNING.toInt()) {
            if (mWakeLock != null) {
                mWakeLock?.release()
                mWakeLock = null
                val intent = Intent()
                intent.action = "android.intent.action.SS_DEVICE_TOUCH"
                sendBroadcast(intent)
            }
        }
        GlobalDevEvent.globalCoverEvent(event, pm)
    }
}

class OptionFactory : IOptionFactory {
    override fun defaultTheme(): Int {
        return 0
    }

    override fun requireOption(theme: Int): IThemeSkinOption? {
        return when (theme) {
            1 -> NightOption()
            else -> null
        }
    }
}

class NightOption : IThemeSkinOption {
    override fun getStandardSkinPackPath(): LinkedHashSet<String> {
        val pathSet = LinkedHashSet<String>()

        pathSet.add(SKIN_PACK_PATH + NIGHT_SKIN_PACK_NAME)
        return pathSet
    }
}

const val NIGHT_SKIN_PACK_NAME = "night.skin"
const val ASSETS_NIGHT_SKIN_PACK = "skins/night.skin"

/**
 * 应用存储空间根路径
 */
private val ROOT_PATH =
    Utils.getApp().getExternalFilesDir(null)?.absolutePath?.run { this + File.separator }
        ?: (PathUtils.getExternalAppDataPath() + "." + AppUtils.getAppPackageName() + File.separator)

/**
 * 皮肤包根路径
 */
val SKIN_PACK_PATH = ROOT_PATH + ".SkinPack" + File.separator