package com.wificonnect

import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import android.net.wifi.WifiInfo
import android.net.wifi.WifiManager
import android.net.wifi.WifiNetworkSpecifier
import android.net.wifi.p2p.WifiP2pManager
import android.os.Build
import android.provider.Settings
import android.util.Log
import androidx.annotation.RequiresApi
import androidx.appcompat.app.AppCompatActivity
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod

class WifiConnectModule(reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {

  private val wifiManager: WifiManager =
    reactApplicationContext.getSystemService(AppCompatActivity.WIFI_SERVICE) as WifiManager
  private var manager: WifiP2pManager =
    reactContext.getSystemService(AppCompatActivity.WIFI_P2P_SERVICE) as WifiP2pManager
  private var channel: WifiP2pManager.Channel =
    manager.initialize(reactContext, reactContext.mainLooper, null)

  private var intentFilter: IntentFilter = IntentFilter()

  init {
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
  }

  override fun getName(): String {
    return NAME
  }

  @ReactMethod
  private fun switch() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
      currentActivity?.startActivity(Intent(Settings.Panel.ACTION_WIFI))
    }
  }

  @ReactMethod
  private fun isOn(promise: Promise) {
    if (wifiManager.isWifiEnabled) {
      promise.resolve(true)
    } else {
      promise.resolve(false)
    }
  }

  @RequiresApi(Build.VERSION_CODES.Q)
  @ReactMethod
  private fun connect(ssid: String, pass: String) {
    if (wifiManager.isWifiEnabled) {
      val connectivityManager: ConnectivityManager = reactApplicationContext
        .getSystemService(AppCompatActivity.CONNECTIVITY_SERVICE) as ConnectivityManager
      val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
          super.onAvailable(network)
          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            connectivityManager.bindProcessToNetwork(network)
          }
        }

        override fun onLost(network: Network) {
          super.onLost(network)
          connectivityManager.bindProcessToNetwork(null)
        }

        override fun onCapabilitiesChanged(
          network: Network,
          networkCapabilities: NetworkCapabilities
        ) {
          val wifiInfo: WifiInfo = networkCapabilities.transportInfo as WifiInfo
          Log.d("Connect", wifiInfo.ssid.toString())
        }
      }
      val wifiNetworkSpecifier = WifiNetworkSpecifier.Builder()
        .setSsid(ssid)
        .setWpa2Passphrase(pass)
        .build()

      val networkRequest = NetworkRequest.Builder()
        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
        .setNetworkSpecifier(wifiNetworkSpecifier)
        .build()

      connectivityManager.requestNetwork(networkRequest, networkCallback)
    } else {
      switch()
    }
  }

  @ReactMethod
  private fun disconnect(promise: Promise) {
    manager.removeGroup(channel, object : WifiP2pManager.ActionListener {
      override fun onSuccess() {
        promise.resolve("Disconnected Successfully!")
      }

      override fun onFailure(p0: Int) {
        promise.resolve("Failed to disconnect!")
      }

    })
  }

  companion object {
    const val NAME = "WifiConnect"
  }
}