Fastestvpn_JetpackCompose/app/src/main/java/com/vpn/fastestvpnservice/utils/VPNConnectionsUtil.kt

package com.vpn.fastestvpnservice.utils

import android.app.Activity
import android.content.BroadcastReceiver
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.ServiceConnection
import android.content.pm.PackageManager
import android.net.ConnectivityManager
import android.net.NetworkCapabilities
import android.os.AsyncTask
import android.os.Build
import android.os.CountDownTimer
import android.os.Handler
import android.os.IBinder
import android.os.RemoteException
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.compose.runtime.livedata.observeAsState
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.vpn.fastestvpnservice.MainActivity
import com.vpn.fastestvpnservice.R
import com.vpn.fastestvpnservice.constants.AppConstant
import de.blinkt.openvpn.core.App
import com.vpn.fastestvpnservice.constants.AppEnum
import com.vpn.fastestvpnservice.constants.splitList
import com.vpn.fastestvpnservice.helpers.BasePreferenceHelper
import com.vpn.fastestvpnservice.helpers.UIHelper
import com.vpn.fastestvpnservice.openVpnUtils.EncryptData
import com.vpn.fastestvpnservice.viewmodels.HomeViewModel
import com.vpn.fastestvpnservice.widgets.SimpleAppWidget
import com.wireguard.android.backend.Backend
import com.wireguard.android.backend.GoBackend
import com.wireguard.android.backend.Tunnel
import com.wireguard.config.Config
import com.wireguard.config.InetEndpoint
import com.wireguard.config.InetNetwork
import com.wireguard.config.Interface
import com.wireguard.config.Peer
import de.blinkt.openvpn.LaunchVPN
import de.blinkt.openvpn.VpnProfile
import de.blinkt.openvpn.core.ConfigParser
import de.blinkt.openvpn.core.ConnectionStatus
import de.blinkt.openvpn.core.IOpenVPNServiceInternal
import de.blinkt.openvpn.core.OpenVPNService
import de.blinkt.openvpn.core.ProfileManager
import de.blinkt.openvpn.core.VpnStatus
import org.json.JSONObject
import org.strongswan.android.logic.CharonVpnService
import org.strongswan.android.ui.VpnProfileControlActivity
import wireguard.WgTunnel
import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.util.SortedSet
import java.util.TreeSet

class VPNConnectionsUtil: VpnStatus.StateListener {

    var context: Context
    var activity: ComponentActivity
    var basePreferenceHelper: BasePreferenceHelper
    var homeViewModel: HomeViewModel
    var countDownTimer: CountDownTimer? = null

    var isBound: Boolean = false

    /* WireGuard */
    var backend: Backend? = null
    final var peerBuilder = Peer.Builder()
    final var tunnel: Tunnel = WgTunnel()
    lateinit var tunnelStatus: Tunnel.State

    /*TCP, UDP*/
    var mService: IOpenVPNServiceInternal? = null
    var inputStream: InputStream? = null
    var bufferedReader: BufferedReader? = null
    var cp: ConfigParser? = null
    var vp: VpnProfile? = null
    var pm: ProfileManager? = null
    var thread: Thread? = null

    private lateinit var openVpnStateReceiver: OpenVpnStateReceiver


    private val mConnection: ServiceConnection = object : ServiceConnection {
        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            App.mService = IOpenVPNServiceInternal.Stub.asInterface(service)
            Log.d("test_openvpn", "onServiceConnected: ${App.mService} $isBound")
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            App.mService = null
            Log.d("test_openvpn", "onServiceDisconnected: ${App.mService} $isBound")
        }
    }

    /*IKEV2*/
    private lateinit var ikevConnectionStatesReceiver: IkevConnectionStatesReceiver

    var dnswg: String = ""

    constructor(context: Context, activity: ComponentActivity, homeViewModel: HomeViewModel) {
        this.context = context
        this.activity = activity
        this.basePreferenceHelper = BasePreferenceHelper(context)
        this.backend = GoBackend(context)
        this.homeViewModel = homeViewModel
    }

    fun startVpn() {
        Log.d("test_wg", "start vpn")
        Log.d("isConnect_State_vpn", "startVPN util")

        countDownTimer()
        try {
            if (CheckInternetConnection.getInternetConnection(context).isConnectedToInternet) {

                if (basePreferenceHelper.getProtocol().title.contentEquals(AppEnum.IKEV2_PROTOCOL.key))
                {
                    basePreferenceHelper.getConnectedServer().let {
                        Log.d("getConnectedServer", "s = ${it?.server_name}")
                    }

                    basePreferenceHelper.getConnectedServer().let { server ->

                        /*Connect IKEV2*/

                        val intent = Intent(context, VpnProfileControlActivity::class.java)
                        App.connection_status = App.CONNECTION_STATE_CONNECTING
                        homeViewModel.setConnectState(App.CONNECTING)

                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
                        widgetIntent1.action = SimpleAppWidget.ACTION_CONNECTING_VPN
                        context.sendBroadcast(widgetIntent1)

                        intent.action = VpnProfileControlActivity.START_PROFILE
                        intent.putExtra(VpnProfileControlActivity.EXTRA_VPN_PROFILE_ID, server?.id)
                        intent.putExtra(AppConstant.SERVER, Gson().toJson(server))
                        intent.putExtra("username", basePreferenceHelper.getUser()?.userinfo?.email)
                        intent.putExtra(
                            "password", basePreferenceHelper.getPassword()
                        )
                        context.startActivity(intent)

                    }
                }
                else if (basePreferenceHelper.getProtocol().title.toLowerCase()
                        .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase())
                ) {

                    /*Connect Wire-Guard*/
                    MainActivity.isWGDown = true
                    vpnWireGuardPermission(true)


                } else {

                    /*Connect UDP / TCP*/
                    startTcpUDP()

                }
            }

        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    fun startTcpUDP() {
        Log.d("Auto test connect", "ACTION_VPN_SERVER_NOT_RESPONDING startTcpUDP")
        Log.d("ServerNotResponding", "startTcpUDP -> ${isBound}")


        /*Connect UDP,TCP*/
        App.connection_status = App.CONNECTION_STATE_CONNECTING
        homeViewModel.setConnectState(App.CONNECTING)

        val widgetIntent = Intent(context, SimpleAppWidget::class.java)
        widgetIntent.action = SimpleAppWidget.ACTION_CONNECTING_VPN
        context.sendBroadcast(widgetIntent)
        Log.d("ServerNotResponding", "startTcpUDP -> CONNECTING")

//        val widgetIntent = Intent(context, SimpleAppWidget::class.java)
//        widgetIntent.action = SimpleAppWidget.ACTION_CONNECTING_VPN
//        context.sendBroadcast(widgetIntent)
        App.isShowNotify = true
        countDownTimer?.start()

        try {
            inputStream = null
            bufferedReader = null
            inputStream = getJsonFileDetails()
            assert(inputStream != null)
            bufferedReader =
                BufferedReader(InputStreamReader(inputStream /*, Charset.forName("UTF-8")*/))
            cp = ConfigParser(context)
            cp!!.parseConfig(bufferedReader)
            vp = cp!!.convertProfile()

            ///////////////// openvpn split tunneling start /////////////////
            val type = object : TypeToken<SortedSet<String?>?>() {}.type

            val selectedApps = Gson().fromJson<SortedSet<String>>(
                basePreferenceHelper.getSplitTunneledApps(), type
            )
            val selectedAppsNoVpn = Gson().fromJson<SortedSet<String>>(
                basePreferenceHelper.getSplitTunneledAppsNotAllow(), type
            )

            if (StaticMethods.isTV(activity))                              // TV
            {
                val listEnable = basePreferenceHelper.getEnableTvAppsSplit()

                if (listEnable?.size == 0) {
                    Log.d("TCP/UDP Split Tunneling", "All apps")
                }
                else
                {
                    val appPackageName: SortedSet<String> = TreeSet()
                    if (listEnable != null){
                        for (i in listEnable.indices) {
                            appPackageName.add(listEnable[i].appPackageName)
                        }
                    }

                    if (appPackageName.size > 0)
                    {
                        for (app in appPackageName)
                        {
                            try {
                                vp?.mAllowedAppsVpn?.add(app)
                                Log.d("packages Vpn", app)
                            } catch (e: PackageManager.NameNotFoundException) {
                                e.printStackTrace()
                            }
                        }
                    }
                }
            }
            else{                                                           // Android
                basePreferenceHelper.getSplitPosition().let {
                    when (it) {
                        splitList[0] -> {}
                        splitList[1] -> {
                            if (selectedApps != null && selectedApps.size > 0) {
                                for (app in selectedApps) {
                                    try {
                                        vp?.mAllowedAppsVpn?.add(app)
                                        Log.d("packages Vpn", app)
                                    } catch (e: PackageManager.NameNotFoundException) {
                                        e.printStackTrace()
                                    }
                                }
                            }
                        }
                        splitList[2] -> {
                            if (selectedAppsNoVpn != null && selectedAppsNoVpn.size > 0) {
                                for (app in selectedAppsNoVpn) {
                                    try {
                                        vp?.mAllowedAppsVpn?.add(app)
                                        Log.d("packages NoVpn", app)
                                    } catch (e: PackageManager.NameNotFoundException) {
                                        e.printStackTrace()
                                    }
                                }
                            }
                        }
                    }
                }
            }

            ///////////////// openvpn split tunneling end /////////////////
            vp?.mAllowedAppsVpnAreDisallowed = false
            val En = EncryptData()
            val AppDetailsValues = En.decrypt(basePreferenceHelper.getAppDetails())

            val json_response = JSONObject(AppDetailsValues)
            val jsonArray = json_response.getJSONArray("blocked")
            for (i in 0 until jsonArray.length()) {
                val json_object = jsonArray.getJSONObject(i)
                vp?.mAllowedAppsVpn?.add(json_object.getString("app"))
                Log.e("packages end", json_object.getString("app"))
            }

            vp?.mName = Build.MODEL
            vp?.mUsername = basePreferenceHelper.getUser()?.userinfo?.email
            vp?.mPassword = basePreferenceHelper.getPassword()
            pm = ProfileManager.getInstance(context)
            pm?.addProfile(vp)
            pm?.saveProfileList(context)
            pm?.saveProfile(context, vp)
            vp = pm?.getProfileByName(Build.MODEL)
            val intent = Intent(context, LaunchVPN::class.java)
            intent.putExtra(LaunchVPN.EXTRA_KEY, vp?.uuid.toString())
            intent.action = Intent.ACTION_MAIN
            context.startActivity(intent)
        }
        catch (e: Exception) {
            e.printStackTrace()
            Log.d("test_openvpn", "catch = ${e.printStackTrace()}")
        }
    }

    fun vpnWireGuardPermission(isUp: Boolean) {

        Log.d("test_wg", "vpnWireGuardPermission = $isUp")

        if (App.backend != null)
        {
            App.backend?.runningTunnelNames
        }
        else {
            val back = GoBackend(context)
            App.setBackend(back)
            App.backend = App.getBackend()
        }

        try{
            Log.d("test_wg", "try = $isUp")
            val intentPrepare: Intent = GoBackend.VpnService.prepare(context)
            if (intentPrepare != null) {
                activity.startActivityForResult(intentPrepare, 552)
            }
        }catch (e :Exception){
            Log.d("test_wg", "catch = $isUp")
            vpnWireGuard(isUp)
        }
    }

    fun vpnWireGuard(isUp: Boolean) {
        Log.d("test_wg", "vpnWireGuard = $isUp")

        dnswg = if (basePreferenceHelper.getAdBlockState()) {
            "10.8.8.8"
        } else {
            "10.9.9.9"
        }

        Log.d("test_wg", "dnswg = $dnswg")


        val interfaceBuilder: Interface.Builder? = Interface.Builder()
        // WireGuard

        AsyncTask.execute {
            try {
                val type = object : TypeToken<SortedSet<String?>?>() {}.type
                val selectedApps = Gson().fromJson<SortedSet<String>>(
                    basePreferenceHelper.getSplitTunneledApps(), type
                )
                val selectedAppsNoVpn = Gson().fromJson<SortedSet<String>>(
                    basePreferenceHelper.getSplitTunneledAppsNotAllow(), type
                )

                if (isUp) {
                    App.tunnelStatus = Tunnel.State.UP
                    homeViewModel.setConnectState(App.CONNECTED)
                    Log.d("test_wg", "tunnelStatus if = ${App.tunnelStatus}")

                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
                    widgetIntent.action = SimpleAppWidget.ACTION_CONNECT_VPN
                    context.sendBroadcast(widgetIntent)

                } else {
                    App.tunnelStatus = Tunnel.State.DOWN
                    homeViewModel.setConnectState(App.DISCONNECTED)
                    Log.d("test_wg", "tunnelStatus else = ${App.tunnelStatus}")

                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
                    widgetIntent.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
                    context.sendBroadcast(widgetIntent)
                }

                val server = basePreferenceHelper.getConnectedServer()
                val wireguard = basePreferenceHelper.getWireGuard()
                Log.d("test_wg", "server = ${server?.server_name}, dns = ${server?.dns}, wg.ip = ${wireguard?.ip}, wg.key = ${wireguard?.key}")

                basePreferenceHelper.getSplitPosition().let {
                    Log.d("test_wg", "getSplitPosition = $it")
                    when(it) {
                        splitList[0] -> {
                            App.backend?.setState(
                                App.getTunnel(), App.tunnelStatus, Config.Builder().setInterface(
                                    interfaceBuilder!!.addAddress(InetNetwork.parse(basePreferenceHelper.getWireGuard()?.ip + "/32"))
                                        .parsePrivateKey(basePreferenceHelper.getWireGuard()?.key)
                                        .parseDnsServers(dnswg)
                                        .build()
                                ).addPeer(
                                    App.peerBuilder.addAllowedIp(InetNetwork.parse("0.0.0.0/0"))
                                        .setEndpoint(InetEndpoint.parse(basePreferenceHelper.getConnectedServer()?.dns + ":51820"))
                                        .parsePublicKey(basePreferenceHelper.getConnectedServer()?.wg_key).build()
                                ).build()
                            )
                        }
                        splitList[1] -> {
                            App.backend?.setState(
                                App.getTunnel(), App.tunnelStatus, Config.Builder().setInterface(
                                    interfaceBuilder!!.addAddress(InetNetwork.parse(basePreferenceHelper.getWireGuard()?.ip + "/32"))
                                        .parsePrivateKey(basePreferenceHelper.getWireGuard()?.key)
                                        .parseDnsServers(dnswg)
                                        .includeApplications(selectedApps)
                                        .build()
                                ).addPeer(
                                    App.peerBuilder.addAllowedIp(InetNetwork.parse("0.0.0.0/0"))
                                        .setEndpoint(InetEndpoint.parse(basePreferenceHelper.getConnectedServer()?.dns + ":51820"))
                                        .parsePublicKey(basePreferenceHelper.getConnectedServer()?.wg_key).build()
                                ).build()
                            )
                        }
                        splitList[2] -> {
                            App.backend?.setState(
                                App.getTunnel(), App.tunnelStatus, Config.Builder().setInterface(
                                    interfaceBuilder!!.addAddress(InetNetwork.parse(basePreferenceHelper.getWireGuard()?.ip + "/32"))
                                        .parsePrivateKey(basePreferenceHelper.getWireGuard()?.key)
                                        .parseDnsServers(dnswg)
                                        .includeApplications(selectedAppsNoVpn)
                                        .build()
                                ).addPeer(
                                    App.peerBuilder.addAllowedIp(InetNetwork.parse("0.0.0.0/0"))
                                        .setEndpoint(InetEndpoint.parse(basePreferenceHelper.getConnectedServer()?.dns + ":51820"))
                                        .parsePublicKey(basePreferenceHelper.getConnectedServer()?.wg_key).build()
                                ).build()
                            )
                        }
                        else -> {}
                    }
                }

                Log.d("test_wg", "${App.backend} ${App.getTunnel()} ${App.tunnelStatus} ${App.peerBuilder}")


            } catch (e: java.lang.Exception) {
                e.printStackTrace()
            }
        }
    }

    fun stopVpn() {
        Log.d("test_wg", "stop vpn")
        Log.d("isConnect_State_vpn", "stopVpn Util")

        try {
//            Log.d("App.connection stop", App.connection_status.toString())

            /*Disconnect IKEV2*/
            if (basePreferenceHelper.getProtocol().title.contentEquals(AppEnum.IKEV2_PROTOCOL.key)) {
                Log.d("isConnect_State_vpn", "Disconnect IKEV2")
                Log.d("ServerNotResponding", "Disconnect IKEV2")
                val intent = Intent(context, VpnProfileControlActivity::class.java)
                intent.action = VpnProfileControlActivity.DISCONNECT
                context.startActivity(intent)

                val connectState = homeViewModel.isConnect.value
                Log.d("disconnect_ikev2", "connectState = $connectState")
                if (connectState == 1) {
                    homeViewModel.setConnectState(App.DISCONNECTED)
                }
            }
            /*Disconnect Wireguard*/
            else if (basePreferenceHelper.getProtocol().title.toLowerCase()
                    .contentEquals(AppEnum.WG_PROTOCOL.key.toLowerCase()))
            {
                Log.d("ServerNotResponding", "Disconnect WG")
                vpnWireGuardPermission(false)

            }
            /*Disconnect TCP,UDP*/
            else {
                Log.d("ServerNotResponding", "Disconnect TCP/UDP")

                App.connection_status = App.CONNECTION_STATE_DISCONNECTED
                homeViewModel.setConnectState(App.DISCONNECTED)

//            val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
//            widgetIntent1.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
//            context.sendBroadcast(widgetIntent1)

                App.isShowNotify = false
                OpenVPNService.abortConnectionVPN = true
                ProfileManager.setConntectedVpnProfileDisconnected(context)
                if (App.mService != null) {
                    Log.d("test_openvpn", "if => ${App.mService}")
                    try {
                        Log.d("test_openvpn", "try => ${App.mService}")
                        App.mService!!.stopVPN(false)
                    } catch (e: RemoteException) {
                        e.printStackTrace()
                    }
                    try {
                        pm = ProfileManager.getInstance(context)
                        vp = pm?.getProfileByName(Build.MODEL)
                        pm?.removeProfile(context, vp)
                    } catch (e: Exception) {
                        e.printStackTrace()
                    }
                }
            }


            if (basePreferenceHelper.getProtocol().index == 0) {
                val state = basePreferenceHelper.isAutoOpenVpnConnected()
                Log.d("ServerNotResponding", "Auto StopVpn $state")
                if (state) {
                    stopTcpUdp()
                }
            }

//            val widgetIntent = Intent(context, SimpleAppWidget::class.java)
//            widgetIntent.action = SimpleAppWidget.ACTION_STOP_SERVICE
//            context.sendBroadcast(widgetIntent)

        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    fun stopTcpUdp() {
        Log.d("ServerNotResponding", "Auto stopTcpUdp")

        App.connection_status = App.CONNECTION_STATE_DISCONNECTED
        homeViewModel.setConnectState(App.DISCONNECTED)
        basePreferenceHelper.setAutoOpenVpnConnected(false)
        App.isShowNotify = false
        OpenVPNService.abortConnectionVPN = true
        ProfileManager.setConntectedVpnProfileDisconnected(context)
        if (App.mService != null) {
            Log.d("test_openvpn", "if => ${App.mService}")
            try {
                Log.d("test_openvpn", "try => ${App.mService}")
                App.mService!!.stopVPN(false)
            } catch (e: RemoteException) {
                e.printStackTrace()
            }
            try {
                pm = ProfileManager.getInstance(context)
                vp = pm?.getProfileByName(Build.MODEL)
                pm?.removeProfile(context, vp)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }

    fun countDownTimer() {
        countDownTimer = object : CountDownTimer(32000, 1000) {
            override fun onTick(millisUntilFinished: Long) {
                val connectState = basePreferenceHelper.getConnectState()
                if (connectState == App.CONNECTED) {
                    countDownTimer!!.cancel()

                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
                    widgetIntent.action = SimpleAppWidget.ACTION_CONNECT_VPN
                    context.sendBroadcast(widgetIntent)
                }
                else if (connectState == App.DISCONNECTED) {
                    countDownTimer!!.cancel()

                    val widgetIntent = Intent(context, SimpleAppWidget::class.java)
                    widgetIntent.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
                    context.sendBroadcast(widgetIntent)
                }
            }

            override fun onFinish() {
                val connectState = basePreferenceHelper.getConnectState()
                if (connectState == App.CONNECTING) {
                    UIHelper.showToast(R.string.server_not_responding)
                    stopVpn()
                }
            }
        }
    }

    inner class IkevConnectionStatesReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            if (intent != null && intent.action != null) {
                val action = intent.action
                when (action) {
                    CharonVpnService.ACTION_VPN_CONNECTED -> {
                        val connectState = homeViewModel.isConnect.value
                        App.connection_status = App.CONNECTION_STATE_CONNECTED
                        Log.d("ikev2_rec_conn", "ACTION_VPN_CONNECTED $connectState")

                        homeViewModel.setConnectState(App.CONNECTED)

                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_CONNECTED (2) $connectState")
                        val connectState1 = basePreferenceHelper.getConnectState()
//                        if (connectState1 == 2) {
//                            val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
//                            widgetIntent1.action = SimpleAppWidget.ACTION_CONNECT_VPN
//                            context?.sendBroadcast(widgetIntent1)
//                        }
                    }
                    CharonVpnService.ACTION_VPN_DISCONNECTED -> {
                        val connectState = homeViewModel.isConnect.value
                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_DISCONNECTED $connectState")

                        if (connectState == App.CONNECTING) {
                            Log.d("vpnConnectionCall_con", "CONNECTING $connectState")
                            App.connection_status = App.CONNECTION_STATE_CONNECTING
                            homeViewModel.setConnectState(App.CONNECTING)

                            val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
                            widgetIntent1.action = SimpleAppWidget.ACTION_CONNECTING_VPN
                            context?.sendBroadcast(widgetIntent1)
                        }
//                        else if (connectState == App.DISCONNECTED) {
//                            App.connection_status = App.CONNECTION_STATE_DISCONNECTED
//                            homeViewModel.setConnectState(App.DISCONNECTED)
//                        }
                        else if (connectState == App.CONNECTED) {
                            Log.d("vpnConnectionCall_ip", "connectState == App.CONNECTED $connectState")
                            App.connection_status = App.CONNECTION_STATE_DISCONNECTED
                            homeViewModel.setConnectState(App.DISCONNECTED)

                            val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
                            widgetIntent1.action = SimpleAppWidget.ACTION_DISCONNECT_VPN
                            context?.sendBroadcast(widgetIntent1)
                        }

                        homeViewModel.getIp()
                    }
                    CharonVpnService.ACTION_VPN_CONNECTING -> {
                        val connectState = homeViewModel.isConnect.value
                        Log.d("vpnConnectionCall_con", "ACTION_VPN_CONNECTING $connectState")
                        App.connection_status = App.CONNECTION_STATE_CONNECTING
                        homeViewModel.setConnectState(App.CONNECTING)

                        val widgetIntent1 = Intent(context, SimpleAppWidget::class.java)
                        widgetIntent1.action = SimpleAppWidget.ACTION_CONNECTING_VPN
                        context?.sendBroadcast(widgetIntent1)
                    }
                    CharonVpnService.ACTION_VPN_SERVER_NOT_RESPONDING -> {
                        Log.d("vpnConnectionCall_ip", "ACTION_VPN_SERVER_NOT_RESPONDING")
                        App.connection_status = App.CONNECTION_STATE_SERVER_NOT_RESPONDING

                        if (basePreferenceHelper.getProtocol().index == 0) {
                            Log.d("ServerNotResponding", "Auto -> ${isBound}")
                            if (MainActivity.isAutoEnabled) {
                                Log.d("test_auto_p", "Inside()")
                                stopVpn()
                                Log.d("test_auto_p", "stopVpn()")
                                Handler().postDelayed(Runnable {
                                    basePreferenceHelper.setAutoOpenVpnConnected(true)
                                    startTcpUDP()
                                    Log.d("test_auto_p", "startTcpUDP()")
                                    Log.d("test_auto_p", "false")
                                }, 1000)
                                MainActivity.isAutoEnabled = false
                                Log.d("test_auto_p", "Out...()")
                            }
                        } else {
                            Log.d("ServerNotResponding", "IKEv2 -> ${isBound}")
                            if (MainActivity.isSnrNotify) {
                                Toast.makeText(
                                    context,
                                    R.string.server_not_responding,
                                    Toast.LENGTH_SHORT
                                ).show()
                                MainActivity.isSnrNotify = false
                            }

                            homeViewModel.setConnectState(App.DISCONNECTED)
                        }

//                        if (context != null) {
//                            ikev2Callback.ServerNotResponding(context, homeViewModel)
//                        }
                    }
                }
            }
        }
    }

    inner class OpenVpnStateReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            if (intent != null && intent.action != null) {
                val action = intent.action
                when (action) {
                    OpenVPNService.ACTION_VPN_CONNECTED -> {
                        Log.d("OpenVpnStateReceiver", "ACTION_VPN_CONNECTED")
                        homeViewModel.setConnectState(App.CONNECTED)
                    }
                }
            }
        }
    }


    fun onStopCallBack() {
        Log.d("test_home_resume", "onStopCallBack!")
        VpnStatus.removeStateListener(this)
    }

    fun onResumeCallBack() {
        Log.d("test_home_resume", "onResumeCallBack!")

        try {
            Log.d("test_openvpn", "mConnection = $mConnection")
            VpnStatus.addStateListener(this)
            val intent = Intent(context, OpenVPNService::class.java)
            intent.action = OpenVPNService.START_SERVICE
            if (!isBound) {
                Log.d("test_openvpn", "mConnection = $mConnection")
                Log.d("test_openvpn", "bindServ:: isBound = $isBound")
                context.bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
                isBound = true
                Log.d("test_openvpn", "bindServ2:: isBound = $isBound")
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }

//        //setting receiver to listen ikev2 protocol connection states

//        App.createIKEV2Listener()

        /* Currently Commenting ... */
//        try {
//            LocalBroadcastManager.getInstance(context)
//                .unregisterReceiver(WireGuardService.ikevConnectionStatesReceiver)
//
//        } catch (e: Exception) {
//            e.printStackTrace()
//        }

        try {
            ikevConnectionStatesReceiver = IkevConnectionStatesReceiver()
            Log.d("test_home_resume", "ikevConnectionStatesReceiver: $ikevConnectionStatesReceiver")
            val filter = IntentFilter()
            filter.addAction(CharonVpnService.ACTION_VPN_CONNECTED)
            filter.addAction(CharonVpnService.ACTION_VPN_DISCONNECTED)
            filter.addAction(CharonVpnService.ACTION_VPN_CONNECTING)
            filter.addAction(CharonVpnService.ACTION_VPN_SERVER_NOT_RESPONDING)
            LocalBroadcastManager.getInstance(context)
                .registerReceiver(ikevConnectionStatesReceiver, filter)
        } catch (e: Exception) {
            e.printStackTrace()
        }

        try {
            openVpnStateReceiver = OpenVpnStateReceiver()
            val filter = IntentFilter()
            filter.addAction(OpenVPNService.ACTION_VPN_CONNECTED)

            LocalBroadcastManager.getInstance(context)
                .registerReceiver(openVpnStateReceiver, filter)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    fun onPauseCallBack() {
        Log.d("test_home_resume", "onPauseCallBack!")
        Log.d("test_openvpn", "pause:: mConnection = $mConnection")
        Log.d("test_openvpn", "pause:: context = $context")

        // TODO uncomment_this_JC
//        if (isBound) {
//            Log.d("test_openvpn", "pause1:: isBound = $isBound")
//            context.unbindService(mConnection)
//        } else {
//            Log.d("test_openvpn", "pause2:: isBound = $isBound")
//        }

//        removing receiver to listen ikev2 protocol connection states

        // TODO uncomment_this_JC
//        try {
//            Log.d("test_home_resume", "onPause = ikevConnectionStatesReceiver: $ikevConnectionStatesReceiver")
//            LocalBroadcastManager.getInstance(context)
//                .unregisterReceiver(ikevConnectionStatesReceiver)
//        } catch (e: Exception) {
//            e.printStackTrace()
//        }

//        try {
//            LocalBroadcastManager.getInstance(context)
//                .unregisterReceiver(openVpnStateReceiver)
//        } catch (e: Exception) {
//            e.printStackTrace()
//        }
    }

    private fun getJsonFileDetails(): InputStream? {
        var conf: InputStream? = null
        try {
            conf = if (basePreferenceHelper.getProtocol().title.equals(AppEnum.TCP_PROTOCOL.key)) {
                context.assets.open("fileDetails/tcp.ovpn")
            } else {
                context.assets.open("fileDetails/udp.ovpn")
            }

            Log.d("test_openvpn", "conf = $conf")

            return conf
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
        return null
    }

    fun isVPNConnected(): Boolean {
        try {
            val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networks = cm.allNetworks
            for (network in networks) {
                val caps = cm.getNetworkCapabilities(network)

                if (caps!!.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) return true
            }
            return false
        } catch (e: Exception) {
            e.printStackTrace()
        }
        return false
    }

    override fun updateState(
        state: String?,
        logmessage: String?,
        localizedResId: Int,
        level: ConnectionStatus?
    ) {
        if (level == ConnectionStatus.LEVEL_NOTCONNECTED) {
            Log.d("vpnConnectionCall ip", "LEVEL_NOTCONNECTED")

            homeViewModel.getIp()
        }
    }

    override fun setConnectedVPN(uuid: String?) {}

}