package com.hdl.photovoltaic.utils;


import android.Manifest;
import android.app.Application;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.SystemClock;
import android.util.Log;

import androidx.core.app.ActivityCompat;


import com.hdl.photovoltaic.HDLApp;

import java.util.ArrayList;
import java.util.List;


public class WifiUtils {

    private static WifiUtils mWifiUtils;
    public WifiManager mWifiManager;
    public WifiManager.WifiLock mWifiLock;

    public Context mContext;

    public static WifiUtils getInstance() {
        if (null == mWifiUtils) {
            synchronized (WifiUtils.class) {
                if (null == mWifiUtils) {
                    mWifiUtils = new WifiUtils();
                }
            }
        }
        return mWifiUtils;
    }

    public WifiUtils() {
        this.mContext = HDLApp.getInstance();
        mWifiManager = (WifiManager) this.mContext.getSystemService(Context.WIFI_SERVICE);
    }

    /**
     * 获取wifi-ssid名称
     *
     * @return 返回ssid名称
     */
    public MyWifiInfo getCurrentConnectWifiInfo() {
        if (mWifiManager == null) {
            return new MyWifiInfo();
        }
        MyWifiInfo myWifiInfo = new MyWifiInfo();
        try {
            WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
            myWifiInfo.setSSID(wifiInfo.getSSID().replace("\"", ""));
        } catch (Exception ignored) {
        }
        return myWifiInfo;
    }

    /**
     * 检测wifi状态
     * WIFI_STATE_DISABLED  0 正在关闭
     * WIFI_STATE_DISABLED 1 已经关闭
     * WIFI_STATE_ENABLING 2 正在打开
     * WIFI_STATE_ENABLED 3 已经打开
     * WIFI_STATE_UNKNOWN 4 未知
     *
     * @return -
     */
    public int checkWifiState() {
        return mWifiManager.getWifiState();
    }

    //打开wifi
    public void openWifiEnabled() {
        if (mWifiManager != null) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    //关闭wifi
    public void colseWifiEnable() {
        if (mWifiManager != null) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    //获取一个WIFILock
    public void crateWifiLock() {
        if (mWifiManager != null) {
            mWifiLock = mWifiManager.createWifiLock("Test");
        }
    }

    //锁定wifi
    public void lockWifi() {
        mWifiLock.acquire();
    }

    //释放wifiLock
    public void releaseWifiLock() {
        if (mWifiLock.isHeld()) {
            mWifiLock.release();
        }
    }

    //获取扫描结果
    public List<ScanResult> getScanResult() {
        List<ScanResult> results = new ArrayList<>();
        try {
            if (mWifiManager != null) {
//                mWifiManager.startScan();
//                SystemClock.sleep(1000);
                results = mWifiManager.getScanResults();
            }
        } catch (Exception ex) {
            Log.d("WifiUtils", ex.getMessage());
        }
        return results;
    }

    //获取已经配置好的网络连接
    public List<WifiConfiguration> getConfigWifiInfo() {
        List<WifiConfiguration> configInfo = new ArrayList<>();
        if (mWifiManager != null) {
            mWifiManager.startScan();
            SystemClock.sleep(1000);
            if (ActivityCompat.checkSelfPermission(this.mContext, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                // TODO: Consider calling
                //    ActivityCompat#requestPermissions
                // here to request the missing permissions, and then overriding
                //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                //                                          int[] grantResults)
                // to handle the case where the user grants the permission. See the documentation
                // for ActivityCompat#requestPermissions for more details.
                return configInfo;
            }
            configInfo = mWifiManager.getConfiguredNetworks();
        }
        return configInfo;
    }


    //断开指定的wifi
    public void disconnectWifi(int netid) {
        if (mWifiManager != null) {
            mWifiManager.disableNetwork(netid);
            mWifiManager.disconnect();
        }
    }

    /**
     * 连接到特定WiFi
     *
     * @param SSID     SSID
     * @param password 密码
     * @param type     加密类型 1.没有密码 2.用wep加密 3.用wpa加密
     */
    public boolean connectWiFi(String SSID, String password, int type) {
        int wcgID = mWifiManager.addNetwork(createConfig(SSID, password, type));
        return mWifiManager.enableNetwork(wcgID, true);
    }

    //获取一个wifi的配置信息
    private WifiConfiguration createConfig(String SSID, String password, int type) {
        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + SSID + "\"";
        // 如果已经连接过WiFi，移除掉
        WifiConfiguration tempConfig = isExsits(SSID);
        if (tempConfig != null) {
            mWifiManager.removeNetwork(tempConfig.networkId);
        }
        if (type == 1) {
            config.wepKeys[0] = "";
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        }
        if (type == 2) {
            config.hiddenSSID = true;
            config.wepKeys[0] = "\"" + password + "\"";
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        }
        if (type == 3) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        }
        return config;
    }

    // 判断当前SSID是否已经连接过
    private WifiConfiguration isExsits(String SSID) {
        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
        if (existingConfigs == null) return null;
        for (WifiConfiguration existingConfig : existingConfigs) {
            if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
                return existingConfig;
            }
        }
        return null;
    }

    /**
     * 获取附近wifi列表
     * 注意:自己定义wifi对象;原生返回wifi调用这个getScanResult()方法
     *
     * @return -
     */
    public List<MyWifiInfo> getCustomWifiDeviceInfo() {
        List<ScanResult> scanResults = getScanResult();//搜索到的设备列表
        List<ScanResult> newScanResultList = new ArrayList<>();
        for (ScanResult scanResult : scanResults) {
            int position = getItemPosition(newScanResultList, scanResult);
            if (position != -1) {
                if (newScanResultList.get(position).level < scanResult.level) {
                    newScanResultList.remove(position);
                    newScanResultList.add(position, scanResult);
                }
            } else {
                newScanResultList.add(scanResult);
            }
        }
        List<MyWifiInfo> wifiList = new ArrayList<>();
        for (int i = 0; i < newScanResultList.size(); i++) {
            MyWifiInfo info = new MyWifiInfo();
            info.setSSID(newScanResultList.get(i).SSID);
            info.setLevel(newScanResultList.get(i).level);
            info.setBSSID(newScanResultList.get(i).BSSID);

            wifiList.add(info);
        }
        return wifiList;
        /*
         * wifi RSSI的等级划分如下：
         *
         * [-126, -88) 或者 [156, 168) 为 0 格
         * [-88, -78) 或者 [168, 178) 为 1 格
         * [-78, -67) 或者 [178, 189) 为 2 格
         * [-67, -55) 或者 [189, 200) 为 3 格
         * [-55, 0] 或者 为 4 格
         */
    }

    /**
     * 返回item在list中的位置
     */
    private int getItemPosition(List<ScanResult> list, ScanResult item) {
        for (int i = 0; i < list.size(); i++) {
            if (item.SSID.equals(list.get(i).SSID)) {
                return i;
            }
        }
        return -1;
    }


    static class MyWifiInfo {
        /**
         * Wi-Fi名称
         */
        private String SSID;
        /**
         * 信号强度
         */
        private int level;
        private String BSSID;

        public String getSSID() {
            return SSID == null ? "" : SSID;
        }

        public void setSSID(String SSID) {
            this.SSID = SSID;
        }

        public int getLevel() {
            return level;
        }

        public void setLevel(int level) {
            this.level = level;
        }

        public String getBSSID() {
            return BSSID == null ? "" : BSSID;
        }

        public void setBSSID(String BSSID) {
            this.BSSID = BSSID;
        }

        private int networkId;

        public int getNetworkId() {
            return networkId;
        }

        public void setNetworkId(int networkId) {
            this.networkId = networkId;
        }
    }
}