package com.google.zxing.client.android.wifi;

import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.util.Log;
import com.google.zxing.client.result.WifiParsedResult;
import java.util.List;
import java.util.regex.Pattern;

/* loaded from: classes.dex */
public final class WifiConfigManager extends AsyncTask<WifiParsedResult, Object, Object> {
    private static final String b = WifiConfigManager.class.getSimpleName();
    private static final Pattern c = Pattern.compile("[0-9A-Fa-f]+");
    private final WifiManager a;

    /* renamed from: com.google.zxing.client.android.wifi.WifiConfigManager$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] a = new int[NetworkType.values().length];

        static {
            try {
                a[NetworkType.WEP.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                a[NetworkType.WPA.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                a[NetworkType.WPA2_EAP.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    public WifiConfigManager(WifiManager wifiManager) {
        this.a = wifiManager;
    }

    private static void b(WifiManager wifiManager, WifiParsedResult wifiParsedResult) {
        WifiConfiguration a = a(wifiParsedResult);
        a.wepKeys[0] = a(wifiParsedResult.g(), 10, 26, 58);
        a.wepTxKeyIndex = 0;
        a.allowedAuthAlgorithms.set(1);
        a.allowedKeyManagement.set(0);
        a.allowedGroupCiphers.set(2);
        a.allowedGroupCiphers.set(3);
        a.allowedGroupCiphers.set(0);
        a.allowedGroupCiphers.set(1);
        a(wifiManager, a);
    }

    private static void c(WifiManager wifiManager, WifiParsedResult wifiParsedResult) {
        WifiConfiguration a = a(wifiParsedResult);
        a.preSharedKey = a(wifiParsedResult.g(), 64);
        a.allowedAuthAlgorithms.set(0);
        a.allowedProtocols.set(0);
        a.allowedProtocols.set(1);
        a.allowedKeyManagement.set(1);
        a.allowedKeyManagement.set(2);
        a.allowedPairwiseCiphers.set(1);
        a.allowedPairwiseCiphers.set(2);
        a.allowedGroupCiphers.set(2);
        a.allowedGroupCiphers.set(3);
        a(wifiManager, a);
    }

    private static void d(WifiManager wifiManager, WifiParsedResult wifiParsedResult) {
        WifiConfiguration a = a(wifiParsedResult);
        a.preSharedKey = a(wifiParsedResult.g(), 64);
        a.allowedAuthAlgorithms.set(0);
        a.allowedProtocols.set(1);
        a.allowedKeyManagement.set(2);
        a.allowedPairwiseCiphers.set(1);
        a.allowedPairwiseCiphers.set(2);
        a.allowedGroupCiphers.set(2);
        a.allowedGroupCiphers.set(3);
        a.enterpriseConfig.setIdentity(wifiParsedResult.e());
        a.enterpriseConfig.setAnonymousIdentity(wifiParsedResult.c());
        a.enterpriseConfig.setPassword(wifiParsedResult.g());
        a.enterpriseConfig.setEapMethod(b(wifiParsedResult.d()));
        a.enterpriseConfig.setPhase2Method(c(wifiParsedResult.h()));
        a(wifiManager, a);
    }

    /* JADX INFO: Access modifiers changed from: protected */
    @Override // android.os.AsyncTask
    /* renamed from: a, reason: merged with bridge method [inline-methods] */
    public Object doInBackground(WifiParsedResult... wifiParsedResultArr) {
        int i = 0;
        WifiParsedResult wifiParsedResult = wifiParsedResultArr[0];
        if (!this.a.isWifiEnabled()) {
            Log.i(b, "Enabling wi-fi...");
            if (!this.a.setWifiEnabled(true)) {
                Log.w(b, "Wi-fi could not be enabled!");
                return null;
            }
            Log.i(b, "Wi-fi enabled");
            while (!this.a.isWifiEnabled()) {
                if (i >= 10) {
                    Log.i(b, "Took too long to enable wi-fi, quitting");
                    return null;
                }
                Log.i(b, "Still waiting for wi-fi to enable...");
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException unused) {
                    Thread.currentThread().interrupt();
                }
                i++;
            }
        }
        try {
            NetworkType a = NetworkType.a(wifiParsedResult.f());
            if (a == NetworkType.NO_PASSWORD) {
                a(this.a, wifiParsedResult);
            } else {
                String g = wifiParsedResult.g();
                if (g != null && !g.isEmpty()) {
                    int i2 = AnonymousClass1.a[a.ordinal()];
                    if (i2 == 1) {
                        b(this.a, wifiParsedResult);
                    } else if (i2 == 2) {
                        c(this.a, wifiParsedResult);
                    } else if (i2 == 3) {
                        d(this.a, wifiParsedResult);
                    }
                }
            }
            return null;
        } catch (IllegalArgumentException unused2) {
            Log.w(b, "Bad network type");
            return null;
        }
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    private static int b(String str) {
        char c2;
        if (str == null) {
            return -1;
        }
        switch (str.hashCode()) {
            case 79645:
                if (str.equals("PWD")) {
                    c2 = 2;
                    break;
                }
                c2 = 65535;
                break;
            case 83163:
                if (str.equals("TLS")) {
                    c2 = 3;
                    break;
                }
                c2 = 65535;
                break;
            case 2402104:
                if (str.equals("NONE")) {
                    c2 = 0;
                    break;
                }
                c2 = 65535;
                break;
            case 2451684:
                if (str.equals("PEAP")) {
                    c2 = 1;
                    break;
                }
                c2 = 65535;
                break;
            case 2585607:
                if (str.equals("TTLS")) {
                    c2 = 4;
                    break;
                }
                c2 = 65535;
                break;
            default:
                c2 = 65535;
                break;
        }
        if (c2 == 0) {
            return -1;
        }
        if (c2 == 1) {
            return 0;
        }
        if (c2 == 2) {
            return 3;
        }
        if (c2 == 3) {
            return 1;
        }
        if (c2 == 4) {
            return 2;
        }
        throw new IllegalArgumentException("Unknown value for EAP method: " + str);
    }

    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    private static int c(String str) {
        if (str == null) {
            return 0;
        }
        char c2 = 65535;
        switch (str.hashCode()) {
            case -2011803142:
                if (str.equals("MSCHAP")) {
                    c2 = 1;
                    break;
                }
                break;
            case -607533546:
                if (str.equals("MSCHAPV2")) {
                    c2 = 2;
                    break;
                }
                break;
            case 70902:
                if (str.equals("GTC")) {
                    c2 = 0;
                    break;
                }
                break;
            case 78975:
                if (str.equals("PAP")) {
                    c2 = 4;
                    break;
                }
                break;
            case 2402104:
                if (str.equals("NONE")) {
                    c2 = 3;
                    break;
                }
                break;
        }
        if (c2 == 0) {
            return 4;
        }
        if (c2 == 1) {
            return 2;
        }
        if (c2 == 2) {
            return 3;
        }
        if (c2 == 3) {
            return 0;
        }
        if (c2 == 4) {
            return 1;
        }
        throw new IllegalArgumentException("Unknown value for phase 2 method: " + str);
    }

    private static void a(WifiManager wifiManager, WifiConfiguration wifiConfiguration) {
        Integer a = a(wifiManager, wifiConfiguration.SSID);
        if (a != null) {
            Log.i(b, "Removing old configuration for network " + wifiConfiguration.SSID);
            wifiManager.removeNetwork(a.intValue());
            wifiManager.saveConfiguration();
        }
        int addNetwork = wifiManager.addNetwork(wifiConfiguration);
        if (addNetwork >= 0) {
            if (wifiManager.enableNetwork(addNetwork, true)) {
                Log.i(b, "Associating to network " + wifiConfiguration.SSID);
                wifiManager.saveConfiguration();
                return;
            }
            Log.w(b, "Failed to enable network " + wifiConfiguration.SSID);
            return;
        }
        Log.w(b, "Unable to add network " + wifiConfiguration.SSID);
    }

    private static WifiConfiguration a(WifiParsedResult wifiParsedResult) {
        WifiConfiguration wifiConfiguration = new WifiConfiguration();
        wifiConfiguration.allowedAuthAlgorithms.clear();
        wifiConfiguration.allowedGroupCiphers.clear();
        wifiConfiguration.allowedKeyManagement.clear();
        wifiConfiguration.allowedPairwiseCiphers.clear();
        wifiConfiguration.allowedProtocols.clear();
        wifiConfiguration.SSID = a(wifiParsedResult.i(), new int[0]);
        wifiConfiguration.hiddenSSID = wifiParsedResult.j();
        return wifiConfiguration;
    }

    private static void a(WifiManager wifiManager, WifiParsedResult wifiParsedResult) {
        WifiConfiguration a = a(wifiParsedResult);
        a.allowedKeyManagement.set(0);
        a(wifiManager, a);
    }

    private static Integer a(WifiManager wifiManager, String str) {
        List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
        if (configuredNetworks == null) {
            return null;
        }
        for (WifiConfiguration wifiConfiguration : configuredNetworks) {
            String str2 = wifiConfiguration.SSID;
            if (str2 != null && str2.equals(str)) {
                return Integer.valueOf(wifiConfiguration.networkId);
            }
        }
        return null;
    }

    private static String a(String str, int... iArr) {
        return a((CharSequence) str, iArr) ? str : a(str);
    }

    private static String a(String str) {
        if (str == null || str.isEmpty()) {
            return null;
        }
        if (str.charAt(0) == '\"' && str.charAt(str.length() - 1) == '\"') {
            return str;
        }
        return '\"' + str + '\"';
    }

    private static boolean a(CharSequence charSequence, int... iArr) {
        if (charSequence != null && c.matcher(charSequence).matches()) {
            if (iArr.length == 0) {
                return true;
            }
            for (int i : iArr) {
                if (charSequence.length() == i) {
                    return true;
                }
            }
        }
        return false;
    }
}