package com.cvte.dss.ups.router.mt76x;

import android.content.Context;
import android.util.Log;
import c.n.a;
import com.cvte.dss.ups.plugin.IUpsPlugin;
import com.cvte.dss.ups.router.mt76x.RouterProxy;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import okhttp3.OkHttpClient;

/* JADX INFO: loaded from: classes.dex */
public class Plugin implements IUpsPlugin {
    private static final int AVERAGE_UPGRADE_SECONDS = 110;
    private static final int PROGRESS_CHECK_TIME_INTERVAL = 1000;
    private static final float PROGRESS_OF_UPGRADE = 0.95f;
    private static final float PROGRESS_OF_UPLOAD_FILE = 0.1f;
    private static final float PROGRESS_STEP = 0.0077272723f;
    private static final String RANDOM_ALPHANUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    private static final int RANDOM_LEN = 4;
    public static final String TAG = "PluginRouterMt76x";
    private static final String TEMP_FILE_TEMPLATE = "/tmp/firmware%s.bin";
    private int mWaitUpgradeTime = 110;
    private float mWaitUpgradeStep = PROGRESS_STEP;
    private RouterProxy mProxy = new RouterProxy(new OkHttpClient.Builder().sslSocketFactory(SSLSocketClient.getSSLSocketFactory(), SSLSocketClient.trustManager).hostnameVerifier(SSLSocketClient.getHostnameVerifier()).connectTimeout(3, TimeUnit.SECONDS).build());

    private String getPropValue(Map<String, Map<String, String>> map, String str, String str2) {
        Map<String, String> map2 = map.get(str);
        if (map2 == null) {
            return null;
        }
        return map2.get(str2);
    }

    private String getRandomTempFileName() {
        StringBuilder sb = new StringBuilder();
        Random random = new Random(System.currentTimeMillis());
        for (int i2 = 0; i2 < 4; i2++) {
            sb.append(RANDOM_ALPHANUM.charAt(Math.abs(random.nextInt()) % 62));
        }
        return String.format(TEMP_FILE_TEMPLATE, sb.toString());
    }

    private void waitForUpgrade(IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) {
        float f2 = PROGRESS_OF_UPLOAD_FILE;
        for (int i2 = 0; i2 < this.mWaitUpgradeTime; i2++) {
            try {
                if (iUpgradeStatusListener != null) {
                    iUpgradeStatusListener.onProcess(f2);
                }
                f2 += this.mWaitUpgradeStep;
                Thread.sleep(1000L);
            } catch (InterruptedException unused) {
                return;
            }
        }
        this.mProxy.connectRouter();
        while (!this.mProxy.isConnectRouter()) {
            f2 += (1.0f - f2) / 4.0f;
            if (iUpgradeStatusListener != null) {
                iUpgradeStatusListener.onProcess(f2);
            }
            Thread.sleep(1000L);
            this.mProxy.connectRouter();
        }
    }

    @Override // com.cvte.dss.ups.plugin.IUpsPlugin
    public IUpsPlugin.FirmwareInfo getFirmwareInfo(Context context) {
        this.mProxy.connectRouter();
        if (!this.mProxy.isConnectRouter()) {
            return null;
        }
        this.mProxy.getWirelessList();
        String otaKey = this.mProxy.getOtaKey();
        String version = this.mProxy.getVersion();
        if (otaKey == null || version == null) {
            return null;
        }
        return new IUpsPlugin.FirmwareInfo("router", "MT76X", "router", version, otaKey, false, false);
    }

    @Override // com.cvte.dss.ups.plugin.IUpsPlugin
    public List<IUpsPlugin.FirmwareInfo> getFirmwareInfos(Context context) {
        return new ArrayList(Collections.singletonList(getFirmwareInfo(context)));
    }

    public RouterProxy.WirelessList removeUnavailableWireless(RouterProxy.WirelessList wirelessList) {
        boolean zIs24GAvailable = this.mProxy.is24GAvailable();
        boolean zIs5GAvailable = this.mProxy.is5GAvailable();
        Iterator<Map.Entry<String, Map<String, String>>> it = wirelessList.ifaces.entrySet().iterator();
        while (it.hasNext()) {
            Map<String, String> map = wirelessList.devices.get(it.next().getValue().get("device"));
            if (map != null) {
                String str = map.get("band");
                if (!zIs5GAvailable && "5G".equals(str)) {
                    it.remove();
                } else if (!zIs24GAvailable && "2G".equals(str)) {
                    it.remove();
                }
            }
        }
        return wirelessList;
    }

    public void restoreWireless(RouterProxy.WirelessList wirelessList) {
        Map<String, String> map;
        String str;
        RouterProxy.WirelessList wirelessList2 = this.mProxy.getWirelessList();
        List<String> listAsList = Arrays.asList("ssid", "key", "hidden", "disabled");
        for (Map.Entry<String, Map<String, String>> entry : wirelessList.ifaces.entrySet()) {
            String key = entry.getKey();
            Map<String, String> value = entry.getValue();
            for (String str2 : listAsList) {
                String str3 = value.get(str2);
                if (str3 != null && !str3.equals(getPropValue(wirelessList2.ifaces, key, str2))) {
                    this.mProxy.setWirelessProp(key, str2, str3);
                }
            }
            String str4 = value.get("device");
            if (str4 != null && (map = wirelessList.devices.get(str4)) != null && (str = map.get("country")) != null && !str.equals(getPropValue(wirelessList2.devices, str4, "country"))) {
                this.mProxy.setWirelessProp(str4, "country", str);
            }
        }
        this.mProxy.commitWireless();
        this.mProxy.reloadWireless();
    }

    public void setWaitUpgradeTime(int i2) {
        this.mWaitUpgradeTime = i2;
        this.mWaitUpgradeStep = 0.84999996f / i2;
    }

    @Override // com.cvte.dss.ups.plugin.IUpsPlugin
    public boolean upgradeFirmware(Context context, String str, boolean z, IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) throws Throwable {
        FileInputStream fileInputStream;
        FileInputStream fileInputStream2 = null;
        try {
            try {
                fileInputStream = new FileInputStream(new File(str));
            } catch (Throwable th) {
                th = th;
            }
        } catch (FileNotFoundException unused) {
        }
        try {
            this.mProxy.connectRouter();
            if (!this.mProxy.isConnectRouter()) {
                a.O(fileInputStream);
                return false;
            }
            RouterProxy.WirelessList wirelessListRemoveUnavailableWireless = removeUnavailableWireless(this.mProxy.getWirelessList());
            String randomTempFileName = getRandomTempFileName();
            this.mProxy.removeFile(randomTempFileName);
            this.mProxy.startUploadServer(randomTempFileName);
            this.mProxy.uploadFile(fileInputStream);
            this.mProxy.routerUpgrade(randomTempFileName);
            waitForUpgrade(iUpgradeStatusListener);
            restoreWireless(wirelessListRemoveUnavailableWireless);
            iUpgradeStatusListener.onComplete();
            a.O(fileInputStream);
            return true;
        } catch (FileNotFoundException unused2) {
            fileInputStream2 = fileInputStream;
            Log.e(TAG, str + " not found");
            a.O(fileInputStream2);
            return false;
        } catch (Throwable th2) {
            th = th2;
            fileInputStream2 = fileInputStream;
            a.O(fileInputStream2);
            throw th;
        }
    }

    @Override // com.cvte.dss.ups.plugin.IUpsPlugin
    public boolean upgradeFirmware(Context context, String str, String str2, boolean z, IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) {
        return upgradeFirmware(context, str2, z, iUpgradeStatusListener);
    }
}