package com.xhly.manageapp


import android.Manifest
import android.app.csdk.CSDKManager
import android.content.ComponentName
import android.content.pm.PackageManager
import android.os.Build
import androidx.core.content.ContextCompat
import androidx.multidex.MultiDexApplication
import com.hjq.toast.Toaster
import com.kongzue.dialogx.DialogX
import com.xhly.corelib.Const
import com.xhly.corelib.utils.LogShow
import com.xhly.corelib.utils.ModelNameUtils
import com.xhly.corelib.utils.SharedPreferencesUtils
import com.xhly.corelib.utils.SystemUtil
import com.xhly.manageapp.bean.user.UserBean
import com.xhly.manageapp.service.websocket.AppSocket
import com.xhly.manageapp.utils.CurrentAppSharedPreferencesUtils
import com.xhly.manageapp.utils.StrategyUtils
import com.xhly.manageapp.utils.ZJAPPUtils
import java.io.File

class ManageApplication : MultiDexApplication() {
    companion object {
        @JvmStatic
        var instance: ManageApplication? = null
            private set
        private var csdkManager: CSDKManager? = null


        /**
         * 加入可安装应用白名单
         */
        fun addInstallPackageWhiteList(pkgList: ArrayList<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                //先移除，再添加。
                removeInstallPackageWhiteList(getInstallPackageWhiteList())
                pkgList.add(Const.CURRENTAPPPKG)
                csdkManager?.addInstallPackageWhiteList(pkgList)
            }
        }

        /**
         * 移除可安装应用白名单
         */
        fun removeInstallPackageWhiteList(pkgList: ArrayList<String>) {
            if ((ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) && pkgList.size > 0) {
                pkgList.remove(Const.CURRENTAPPPKG)
                csdkManager?.removeInstallPackageWhiteList(pkgList)
            }
        }


        /**
         * 获取应用白名单
         */
        fun getInstallPackageWhiteList(): ArrayList<String> {
            try {
                if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                    return csdkManager?.installPackageWhiteList as ArrayList<String>
                }
            } catch (e: Exception) {

            }
            return arrayListOf()
        }

        /**
         * 安装应用
         */

        fun installPackage(string: String) {
            enableAllUnkownsourcesV3(true)
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                LogShow("开始安装$string" + File(string).exists())
                csdkManager?.installPackage(string)
            } else {
                instance?.let {
                    ZJAPPUtils.installApk(it, File(string))
                }
            }
        }

        /**
         * 卸载应用
         */

        fun uninstallPackage(pkg: String) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                if (pkg == Const.CURRENTAPPPKG || pkg == Const.STOREAPPPKG) {
                    //不卸载管控和商店
                    return
                }
                csdkManager?.uninstallPackage(pkg, false)
            }
        }

        /**
         * 禁止安装app,true：禁止安装应用 false：取消禁止安装应用,禁止时静默安装只能安装白名单内的应用，不禁止时静默安装可以安装白名单外的应用
         */
        fun disableInstallation(isInstall: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disableInstallation(isInstall)
            }
        }

        /**
         * 冻结应用true：显示应用可以使用; false：隐藏应用不可用
         */
        fun setPackageEnabled(pkg: String, enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setPackageEnabled(pkg, enableFlag)
            }
        }

        /**
         * 设置显示黑名单,控制桌面是否显示图标
         */
        fun setDisplayBlacklist(pkgList: ArrayList<String>) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.displayBlacklist_v3 = pkgList
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.displayBlacklistV3 = pkgList
            }
        }

        /**
         * 杀进程
         */
        fun killApplicationProcess(pkg: String) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.killApplicationProcess(pkg)
            }
        }

        /**
         * 禁用摄像头 true：禁用相机
         * false：启用相机
         */
        fun disableCamera(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disableCamera(enableFlag)
            }
        }

        /**
         * 打开关闭蓝牙true：打开蓝牙
         * false：关闭蓝牙
         */
        fun enableBluetooth(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.enableBluetooth_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableBluetoothV3(enableFlag)
            }
        }

        /**
         * 允许用户操作usb调试。  true：禁止设置 USB 调试 false：允许设置 USB 调试
         */
        fun disallowUsbDebugging(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowUsbDebugging_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowUsbDebuggingV3(enableFlag)
            }
        }

        /**
         * 禁止用户操作 wifi true：不可操作false：可以操作
         */
        fun disallowWifi(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowWifi_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowWifiV3(enableFlag)
            }
        }

        /**
         * 打开关闭 wifi true：打开 wifi false：关闭 wifi(禁用这个方法，防止用户误操作)
         */
        fun enableWifi(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
               csdkManager?.enableWifi_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
               csdkManager?.enableWifiV3(enableFlag)
            }
        }

        /**
         * 禁止用户操作移动数据 true：不可操作 false：可以操作
         */
        fun disallowData(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowData_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowDataV3(enableFlag)
            }
        }

        /**
         * 打开关闭移动数据 true：打开 false：关闭
         */
        fun enableData(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.enableData_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableDataV3(enableFlag)
            }
        }

        /**
         * 禁止操作位置 true：不可操作 false：可以操作
         */
        fun disallowLocation(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowLocation_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowLocationV3(enableFlag)
            }
        }

        /**
         * 打开关闭位置 true：打开 false：关闭
         */
        fun enableLocation(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.enableLocation_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableLocationV3(enableFlag)
            }
        }

        /**
         * 禁止操作 wifi 高级设置 true：不可操作 false：可以操作
         */
        fun disallowWifiAdvanceSettings(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowWifiadvancesettings_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowWifiAdvanceSettingsV3(enableFlag)
            }
        }

        /**
         *禁用/启用SD卡 true：允许连接外部存储设备
         */
        fun enableMassStorage(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableMassStorage(enableFlag)
            }
        }

        /**
         *禁用/启用OTG true：允许连接外部OTG
         */
        fun setCustomOTG(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.customOTG = enableFlag
            }
        }


        /**
         *禁止手动切换桌面 true: 禁止手动切换桌面；false: 允许手动切换桌面
         */
        fun disallowSwitchLauncher_v3(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowSwitchLauncher_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowSwitchLauncherV3(enableFlag)
            }
        }

        /**
         * 设置运行时权限
         */
        fun setRuntimePermissions(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setRuntimePermissions(enableFlag)
            }
        }

        /**
         * "设备Mac地址", "设备SN号", "获取设备型号信息", "获取设备IMEI信息" 1,2,3,4
         */
        fun getDeviceInfo(type: Int = 2): String? {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                return csdkManager?.getDeviceInfo(type)
            }
            try {
                if (instance != null && ContextCompat.checkSelfPermission(
                        instance!!.applicationContext,
                        Manifest.permission.READ_PHONE_STATE
                    ) == PackageManager.PERMISSION_GRANTED
                ) {
                    val serial = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        Build.getSerial()
                    } else {
                        Build.SERIAL
                    }
                    return if (serial.isNullOrBlank()) {
                        ""
                    } else {
                        serial
                    }
                } else {
                    return ""
                }
            } catch (e: Exception) {
                return ""
            }
        }

        /**
         * 恢复出场设置
         */
        fun launchFactoryReset() {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.launchFactoryReset()
            }
        }

        /**
         *重启设备
         */

        fun rebootDevice() {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.rebootDevice()
            }
        }

        /**
         * 增加wifi白名单
         */
        fun addWifiWhiteList(list: List<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                //csdkManager?.addWifiWhiteList(list)
                setWifiWhiteList(list)
            }
        }

        /**
         * 增加wifi白名单
         */
        fun setWifiWhiteList(list: List<String>) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.wifiWhiteList = list
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                enableWifiWhiteList(true)
                csdkManager?.addWifiWhiteList(list)
            }
        }

        /**
         * 启用wifi白名单x505f没有启用方法，移除就是启用
         */
        fun enableWifiWhiteList(enable: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                //csdkManager?.whitelist
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableWifiWhiteList(enable)
            }
        }

        /**
         * 移除wifi白名单
         */
        fun removeWifiWhiteList(list: List<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.removeWifiWhiteList(list)
            }
        }

        /**
         * 获得wifi白名单
         */
        fun getWifiWhiteList(): List<String> {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                val wifiWhiteList = csdkManager?.wifiWhiteList
                if (wifiWhiteList != null) {
                    return wifiWhiteList
                }
            }
            return listOf<String>()
        }

        /**
         * 启用无障碍服务
         */
        fun enableAccessibility() {
            if (ModelNameUtils.IS_LianxX505f()) {
                //csdkManager?.enableAccessibility("com.xhly.manageapp","com.xhly.manageapp.service.TestService",true)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableAccessibility(
                    "com.xhkjedu.manageapp",
                    "com.xhkjedu.manageapp.service.ManageAccessibilityService",
                    true
                )
            }
        }

        /**
         * 禁用/启用截屏 true：允许截屏
         */
        fun enableCaptureScreen(enable: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.enableCaptureScreen_v3(enable)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableCaptureScreenV3(enable)
            }
        }

        /**
         * 禁止/允许 设置自动旋转屏幕 true：禁止设置自动旋转屏幕
         */
        fun disallowSetAutoRotation(enable: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                //csdkManager?.disallowSetAutoRotation(enable)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                //csdkManager?.disallowSetAutoRotation(enable)
            }
        }

        /**
         * 隐藏底部返回键
         */
        fun hideBackSoftKey(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.hideBackSoftKey(enableFlag)
            }
        }

        /**
         * 隐藏底部菜单键
         */
        fun hideMenuSoftKey(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.hideMenuSoftKey(enableFlag)
            }
        }


        /**
         * 隐藏底部home键
         */
        fun hideHomeSoftKey(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.hideHomeSoftKey(enableFlag)
            }
        }

        /**
         * 隐藏电源，音量键int：24, 25, 26(音量上，音量下，电源键) true：启用
         */
        fun requestKeyControl_V3(code: Int, enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.requestKeyControl_V3(code, enableFlag)
            }
        }

        /**
         * 禁用 app 中某一个组件  newState：组件新的状态，可以设置三个值，
         * 分别如下：
         * 不可用状态：COMPONENT_ENABLED_STATE_DISABLED
         * 可用状态：COMPONENT_ENABLED_STATE_ENABLED
         * 默认状态：COMPONENT_ENABLED_STATE_DEFAULT
         * flags：
         * 行为标签，值可以是 DONT_KILL_APP 或者 0，0 表
         * 示杀死包含该组件的 app
         */

        fun setComponentEnabled(componentName: ComponentName, newstate: Int, flag: Int) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setComponentEnabled(componentName, newstate, flag)
            }
        }

        /**
         * 设置启动器
         */
        fun setCustomLauncher(pkg: String, activityName: String) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setCustomLauncher(pkg, activityName)
            }
        }

        /**
         * 禁止用户操作飞行模式true：不可操作
         * false：可以操作
         */
        fun disallowAirplaneMode_v3(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.disallowAirplaneMode_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disallowAirplaneModeV3(enableFlag)
            }
        }


        /**
         * 隐藏状态栏true：隐藏状态栏
         * false：显示状态栏
         */
        fun hideStatusBar(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()||ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.hideStatusBar(enableFlag)
            }
        }

        /**
         * 禁止状态栏下拉true：禁止状态栏下拉
         * false：启用状态栏下拉
         */
        fun disableStatusBarPanel(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()||ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.disableStatusBarPanel(enableFlag)
            }
        }

        /**
         * 打开/关闭 app 的安装未知源权限
         * true：app 未知来源权限开启
         * false：app 未知来源权限关闭
         */
        fun enableAllUnkownsourcesV3(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.enableAllUnkownsources_v3(enableFlag)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableAllUnkownsourcesV3(enableFlag)
            }
        }

        /**
         * 将 USB 调试打开或关闭true：打开 USB 调试
         * false：关闭 USB 调试
         */
        fun enableUsbDebugging(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.enableUsbDebugging(enableFlag)
            }
        }

        /**
         *设置系统时间
         */
        fun setSysTime(time: Long) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setSysTime(time)
            }
        }

        /**
         * 添加网络白名单
         */
        fun setUrlWhiteListWrite(list: ArrayList<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                setUrlWhiteListEnable(true)
                //先清除再添加
                ClearIpHostRules()
                csdkManager?.urlWhiteListWrite(list)
                csdkManager?.urlBlackListWrite(arrayListOf("*"))
            }
        }

        /**
         * 启动网络白名单true启动，false关闭
         */
        fun setUrlWhiteListEnable(enableFlag: Boolean) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.SetEnable(enableFlag)
            }
        }

        /**
         * 移除网络白名单505f使用这个
         */
        fun ClearIpHostRules(): Boolean {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                val clearIpHostRules = csdkManager?.ClearIpHostRules()
                clearIpHostRules?.let {
                    return it
                }
            }
            return false
        }

        /**
         * 移除网络白名单
         */
        fun removeNetworkAccessWhitelist(list: List<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.removeNetworkAccessWhitelist(list)
            }
        }


        /**
         * 清除应用数据
         */
        //TODO 6E6F可能不存在这个方法
        fun clearAppData(pkgList: ArrayList<String>) {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                pkgList.forEach {
                    csdkManager?.clearAppData(it)
                }
            }
        }

        /**
         * 添加网络应用白名单
         */
        fun addAppWhiteRule(pkgList: ArrayList<String>) {
            clearAppWhiteRule()
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                pkgList.forEach {
                    csdkManager?.AddAppWhiteRule(it)
                }
            }
        }

        /**
         * 移除网络应用白名单
         */
        fun clearAppWhiteRule() {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.ClearAppRules()
                //不移除自己和商店
                csdkManager?.AddAppWhiteRule(Const.CURRENTAPPPKG)
                csdkManager?.AddAppWhiteRule(Const.STOREAPPPKG)
            }
        }

        /**
         * 获得App网络白名单
         */
        fun GetAppWhiteRules():ArrayList<String>{
            val appList= arrayListOf<String>()
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                var appWhiteRules = csdkManager?.appWhiteRules
                appWhiteRules?.let {
                    appList.addAll(it)
                }
            }
            return appList
        }

        /**
         * 设置系统熄屏时间  设 置 的 系 统 熄 屏 时 间 的 值 （ 范 围 [10,
         * 2147483647]，单位毫秒）
         */
        fun setSleepTimeoutV3(time: Int = 1000 * 60 * 60) {
            if (ModelNameUtils.IS_LianxX505f()) {
                csdkManager?.setSleepTimeout_V3(time)
            } else if (ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.setSleepTimeoutV3(time)
            }
        }

        /**
         * 获得网址白名单
         */
        fun urlWhiteListRead(): List<String> {
            if (ModelNameUtils.IS_LianxX505f() || ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager?.urlWhiteListRead()?.let {
                    return it
                }
            }
            return arrayListOf()
        }
    }

    override fun onCreate() {
        super.onCreate()
        val processName = SystemUtil.getProcessName(this, android.os.Process.myPid())
        if (processName != null && processName.equals(packageName)) {
            instance = this
            val spUtils = SharedPreferencesUtils.getInstance(this)
            //获取是否已经解除管控
            val currentSpUtils by lazy { CurrentAppSharedPreferencesUtils.getInstance(this) }
            val exitControlFlag = currentSpUtils.getParam(Const.EXIT_CONTROL, false) as Boolean
            Toaster.init(this)
            DialogX.init(this)
            if (ModelNameUtils.IS_LianxX505f()||ModelNameUtils.IS_LianxX6e6f()) {
                csdkManager = CSDKManager(this)
                //允许运行时权限
                setRuntimePermissions(true)
                enableAllUnkownsourcesV3(true)
            }
            //如果解除管控为真，则不在执行以下代码
            try {
                val userBean = spUtils.getFromJson(
                    Const.USERINFO, UserBean().javaClass
                ) as UserBean
                Const.USERID = userBean.userid
                Const.SCHOOLID = userBean.schoolid
                Const.CLASSID = userBean.classid
                Const.USERNAME = userBean.username
                if (!exitControlFlag) {
                    //未解除管控才使用socket
                    AppSocket.startSocket(this)
                }
            } catch (e: Exception) {

            }
            if (!exitControlFlag) {
                StrategyUtils.initControlStrategy()
            }
        }
    }


    override fun onTerminate() {
        super.onTerminate()
        val processName = SystemUtil.getProcessName(this, android.os.Process.myPid())
        if (processName != null && processName.equals(packageName)) {
            AppSocket.onDestroy()
        }
    }
}