package com.bytedance.sdk.openadsdk.wsy;

import android.text.TextUtils;
import com.bykv.vk.openvk.preload.falconx.loader.ILoader;
import com.bykv.vk.openvk.preload.geckox.GeckoHubImp;
import com.bykv.vk.openvk.preload.geckox.IThreadPoolCallback;
import com.bykv.vk.openvk.preload.geckox.model.WebResourceResponseModel;
import com.bykv.vk.openvk.preload.geckox.statistic.IStatisticMonitor;
import com.bytedance.sdk.component.utils.wey;
import com.bytedance.sdk.openadsdk.core.dsz;
import com.bytedance.sdk.openadsdk.core.gof;
import com.bytedance.sdk.openadsdk.core.model.lse;
import com.bytedance.sdk.openadsdk.irt.yz;
import com.bytedance.sdk.openadsdk.utils.xgn;
import com.bytedance.sdk.openadsdk.yz.lb;
import java.security.SecureRandom;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import org.json.JSONObject;

/* JADX INFO: loaded from: classes2.dex */
public class ro {
    private static final String[] fm = {"gecko16-normal-useast5.tiktokv.us"};

    public interface fm {
        void fm();
    }

    /* JADX INFO: renamed from: com.bytedance.sdk.openadsdk.wsy.ro$ro, reason: collision with other inner class name */
    public static class C0110ro {
        private static final ro fm = new ro();
    }

    public static void lb() {
        try {
            GeckoHubImp.setThreadPoolExecutorCallback(new IThreadPoolCallback() { // from class: com.bytedance.sdk.openadsdk.wsy.ro.2
                @Override // com.bykv.vk.openvk.preload.geckox.IThreadPoolCallback
                public ExecutorService getThreadPool() {
                    return xgn.jnr();
                }
            });
        } catch (Throwable th) {
            wey.fm("GeckoHub", "setThreadPoolExecutor error", th);
        }
    }

    private static String yz() {
        String[] strArrAws = gof.yz().aws();
        if (strArrAws == null) {
            strArrAws = fm;
        }
        String str = strArrAws[new SecureRandom().nextInt(strArrAws.length)];
        if (!TextUtils.isEmpty(str)) {
            return str;
        }
        SecureRandom secureRandom = new SecureRandom();
        String[] strArr = fm;
        return strArr[secureRandom.nextInt(strArr.length)];
    }

    public ILoader ro() {
        try {
            return GeckoHubImp.inst(gof.fm()).getGeckoResLoader();
        } catch (Throwable th) {
            wey.fm("GeckoHub", "getGeckoResLoader error", th);
            return null;
        }
    }

    private ro() {
        try {
            GeckoHubImp.inst(gof.fm());
        } catch (Throwable th) {
            wey.fm("GeckoHub", "GeckoHubImp init error", th);
        }
    }

    public static ro fm() {
        return C0110ro.fm;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void ro(Map<String, lse> map, JSONObject jSONObject, String str) {
        try {
            JSONObject jSONObject2 = new JSONObject();
            if (jSONObject == null) {
                jSONObject2.put("success", false);
                jSONObject2.put("msg", str);
                jSONObject2.put("code", 1);
                jSONObject = jSONObject2;
            }
            Iterator<lse> it = map.values().iterator();
            while (it.hasNext()) {
                yz.fm(it.next(), jSONObject);
            }
        } catch (Throwable th) {
            wey.fm("GeckoHub", "upLoadStateEvent error", th);
        }
    }

    public void fm(Map<String, lse> map) {
        fm(map, (fm) null, false);
    }

    public void fm(final Map<String, lse> map, final fm fmVar, boolean z10) {
        try {
            String strFm = dsz.fm(gof.fm());
            if (TextUtils.isEmpty(strFm)) {
                return;
            }
            for (lse lseVar : map.values()) {
                if (lseVar != null) {
                    if (!z10 && lseVar.dbt()) {
                        map.remove(lseVar.kec());
                    } else {
                        yz.ro(lseVar);
                    }
                }
            }
            if (map.isEmpty()) {
                return;
            }
            GeckoHubImp.setRandomHost(yz());
            GeckoHubImp.inst(gof.fm()).preload(strFm, new IStatisticMonitor() { // from class: com.bytedance.sdk.openadsdk.wsy.ro.1
                @Override // com.bykv.vk.openvk.preload.geckox.statistic.IStatisticMonitor
                public void upload(String str, JSONObject jSONObject) {
                    if ("geckosdk_update_stats".equals(str)) {
                        lse lseVar2 = (lse) map.get(jSONObject.optString("channel"));
                        if (lseVar2 != null) {
                            lb.fm.fm(str, jSONObject, lseVar2);
                            return;
                        }
                        return;
                    }
                    if ("download_gecko_end".equals(str)) {
                        fm fmVar2 = fmVar;
                        if (fmVar2 != null) {
                            fmVar2.fm();
                        }
                        ro.ro(map, jSONObject, "");
                    }
                }
            }, map.keySet(), new com.bytedance.sdk.openadsdk.wsy.fm());
        } catch (Throwable th) {
            ro(map, null, th.toString());
            wey.fm("GeckoHub", "releaseGeckoResLoader error", th);
        }
    }

    public void fm(ILoader iLoader) {
        if (iLoader != null) {
            try {
                GeckoHubImp.inst(gof.fm()).releaseGeckoResLoader(iLoader);
            } catch (Throwable th) {
                wey.fm("GeckoHub", "releaseGeckoResLoader error", th);
            }
        }
    }

    public WebResourceResponseModel fm(ILoader iLoader, String str, String str2) {
        if (iLoader == null) {
            return null;
        }
        try {
            return GeckoHubImp.inst(gof.fm()).findResAndMsg(iLoader, str, str2);
        } catch (Throwable th) {
            wey.fm("GeckoHub", "findRes error", th);
            return null;
        }
    }

    public int fm(ILoader iLoader, String str) {
        try {
            return GeckoHubImp.inst(gof.fm()).getResCount(iLoader, str);
        } catch (Throwable th) {
            wey.fm("GeckoHub", "getResCount error", th);
            return 0;
        }
    }
}