package com.bytedance.sdk.openadsdk.hlt;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.Handler;
import android.os.HandlerThread;
import android.text.TextUtils;
import androidx.media3.exoplayer.rtsp.RtspHeaders;
import com.bytedance.sdk.component.adexpress.dynamic.dynamicview.b;
import com.bytedance.sdk.component.embedapplog.PangleEncryptConstant;
import com.bytedance.sdk.component.embedapplog.PangleEncryptManager;
import com.bytedance.sdk.component.pglcrypt.PglCryptUtils;
import com.bytedance.sdk.component.utils.nt;
import com.bytedance.sdk.component.utils.sds;
import com.bytedance.sdk.component.utils.wey;
import com.bytedance.sdk.component.utils.wu;
import com.bytedance.sdk.openadsdk.core.fhx;
import com.bytedance.sdk.openadsdk.core.gof;
import com.bytedance.sdk.openadsdk.core.hi;
import com.bytedance.sdk.openadsdk.core.hlt;
import com.bytedance.sdk.openadsdk.core.model.ai;
import com.bytedance.sdk.openadsdk.core.settings.ef;
import com.bytedance.sdk.openadsdk.core.settings.ku;
import com.bytedance.sdk.openadsdk.core.vt;
import com.bytedance.sdk.openadsdk.hlt.ro;
import com.bytedance.sdk.openadsdk.utils.bx;
import com.bytedance.sdk.openadsdk.utils.lse;
import com.bytedance.sdk.openadsdk.utils.xgn;
import com.pgl.ssdk.ces.out.PglSSConfig;
import defpackage.e;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import org.json.JSONException;
import org.json.JSONObject;

/* JADX INFO: loaded from: classes2.dex */
public class jnr {
    public static String ro;
    private static volatile yz yz;

    /* JADX INFO: renamed from: lb, reason: collision with root package name */
    private static final AtomicBoolean f7423lb = new AtomicBoolean(false);
    public static final ConcurrentHashMap<String, Object> fm = new ConcurrentHashMap<>();

    public static int ajl() {
        if (lb()) {
            return fm("ad_load_and_render_opt", "webview_preload_cache", 0);
        }
        return 0;
    }

    private static yz duv() {
        return fm(gof.fm(), vt.ro().yz());
    }

    public static boolean ef() {
        return fm("no_call_close", 0) == 1;
    }

    public static yz fm(final Context context, final String str) {
        if (yz == null) {
            synchronized (jnr.class) {
                try {
                    if (yz == null) {
                        try {
                            yz yzVar = new yz(new ajl() { // from class: com.bytedance.sdk.openadsdk.hlt.jnr.1
                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public JSONObject ajl() {
                                    try {
                                        JSONObject jSONObjectFm = ef.fm(nt.fm(gof.fm(), 0L));
                                        if (!jSONObjectFm.has("app_id")) {
                                            if (!TextUtils.isEmpty(str)) {
                                                jSONObjectFm.put("app_id", str);
                                            } else {
                                                if (TextUtils.isEmpty(vt.ro().yz())) {
                                                    return null;
                                                }
                                                jSONObjectFm.put("app_id", vt.ro().yz());
                                            }
                                        }
                                        return hlt.fm(PangleEncryptConstant.CryptDataScene.STRATEGY, jSONObjectFm);
                                    } catch (Throwable th) {
                                        wey.lb("StrategyUtils", th.getMessage());
                                        return null;
                                    }
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public ExecutorService fm() {
                                    return xgn.jnr();
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public String jnr() {
                                    String strFm = bx.fm("/api/ad/union/sdk/strategies/adn", false, true);
                                    jnr.ro = strFm;
                                    return strFm;
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public String lb() {
                                    if (sds.fm(ro())) {
                                        return "pag_adn_strategy_center";
                                    }
                                    return "pag_adn_strategy_center_" + sds.lb(ro());
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public Context ro() {
                                    Context context2 = context;
                                    return context2 != null ? context2 : gof.fm();
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public Map<String, String> wsy() {
                                    HashMap map = new HashMap();
                                    map.put(RtspHeaders.USER_AGENT, bx.yz());
                                    String strRo = com.bytedance.sdk.openadsdk.gqi.yz.fm.ro("ttopenadsdk", PglSSConfig.CUSTOMINFO_KEY_IPV6, "");
                                    if (!strRo.isEmpty()) {
                                        JSONObject jSONObject = new JSONObject();
                                        try {
                                            jSONObject.put("ipv6", strRo);
                                        } catch (JSONException unused) {
                                        }
                                        JSONObject jSONObjectEncryptType4 = PangleEncryptManager.encryptType4(jSONObject, new hi(PangleEncryptConstant.CryptDataScene.UNKNOWN));
                                        if (jSONObjectEncryptType4 != null) {
                                            map.put("transfer-param", jSONObjectEncryptType4.optString(PglCryptUtils.KEY_MESSAGE));
                                            if (jSONObjectEncryptType4.optInt("cypher") == 4) {
                                                map.put("cypher", "4");
                                            } else {
                                                map.put("cypher", "3");
                                            }
                                        }
                                    }
                                    try {
                                        map.put("x-pangle-target-idc", ku.ro().lsa());
                                    } catch (Throwable unused2) {
                                    }
                                    return map;
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public boolean wu() {
                                    return com.bytedance.sdk.openadsdk.core.ku.ro.fm().jnr();
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public Handler yz() {
                                    return fhx.ro();
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public JSONObject fm(JSONObject jSONObject) {
                                    String strFm = hlt.fm(jSONObject.optInt("cypher", -1), jSONObject.optString(PglCryptUtils.KEY_MESSAGE));
                                    if (TextUtils.isEmpty(strFm)) {
                                        return jSONObject;
                                    }
                                    try {
                                        return new JSONObject(strFm);
                                    } catch (Throwable unused) {
                                        return jSONObject;
                                    }
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.ajl
                                public HandlerThread fm(String str2, int i10) {
                                    return wu.fm(str2, i10);
                                }
                            });
                            yz = yzVar;
                            yzVar.fm(new fm() { // from class: com.bytedance.sdk.openadsdk.hlt.jnr.2
                                @Override // com.bytedance.sdk.openadsdk.hlt.fm
                                public void fm() {
                                    com.bytedance.sdk.openadsdk.gof.lb.fm(new com.bytedance.sdk.openadsdk.gof.yz() { // from class: com.bytedance.sdk.openadsdk.hlt.jnr.2.1
                                        @Override // com.bytedance.sdk.openadsdk.gof.yz
                                        public com.bytedance.sdk.openadsdk.gof.ro.fm fm() {
                                            return b.d("strategy_fetch");
                                        }
                                    });
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.fm
                                public void ro() {
                                    com.bytedance.sdk.openadsdk.gof.lb.ro(new com.bytedance.sdk.openadsdk.gof.yz() { // from class: com.bytedance.sdk.openadsdk.hlt.jnr.2.2
                                        @Override // com.bytedance.sdk.openadsdk.gof.yz
                                        public com.bytedance.sdk.openadsdk.gof.ro.fm fm() {
                                            return b.d("strategy_fetch");
                                        }
                                    });
                                    com.bytedance.sdk.openadsdk.ajl.fm.fm().ro();
                                    com.bytedance.sdk.openadsdk.maa.fm.lb.fm().ro();
                                    lse.ro();
                                    HashMap map = new HashMap();
                                    String strFm = jnr.fm(PglSSConfig.CUSTOMINFO_KEY_SEC_CONFIG_STR, "");
                                    if (!TextUtils.isEmpty(strFm)) {
                                        map.put(PglSSConfig.CUSTOMINFO_KEY_SEC_CONFIG_STR, strFm);
                                    }
                                    com.bytedance.sdk.openadsdk.core.duv.lb.fm(map);
                                }

                                @Override // com.bytedance.sdk.openadsdk.hlt.fm
                                public void fm(int i10, String str2) {
                                    com.bytedance.sdk.openadsdk.gof.lb.lb(new com.bytedance.sdk.openadsdk.gof.yz() { // from class: com.bytedance.sdk.openadsdk.hlt.jnr.2.3
                                        @Override // com.bytedance.sdk.openadsdk.gof.yz
                                        public com.bytedance.sdk.openadsdk.gof.ro.fm fm() {
                                            return b.d("strategy_fetch");
                                        }
                                    });
                                    lse.fm(jnr.ro);
                                }
                            });
                        } catch (Throwable th) {
                            th.getMessage();
                        }
                    }
                } catch (Throwable th2) {
                    throw th2;
                }
            }
        }
        return yz;
    }

    public static boolean jnr() {
        return lb() && fm("ad_load_and_render_opt", "sync_barrier_switch_opt", 0) == 1;
    }

    public static boolean ku() {
        return fm("iv_rv_top_bar_listen_new", 0) == 1;
    }

    public static boolean lb() {
        return fm("ad_load_and_render_opt", "enable", 0) == 1;
    }

    public static void ro() {
        yz yzVarDuv;
        if (com.bytedance.sdk.openadsdk.core.ku.ro.fm().jnr() || (yzVarDuv = duv()) == null || f7423lb.getAndSet(true)) {
            return;
        }
        yzVarDuv.fm();
    }

    public static boolean vt() {
        return fm("iv_rv_listen_new_arch", 0) == 1;
    }

    public static int wsy() {
        if (lb()) {
            return fm("ad_load_and_render_opt", "webview_preload_cache_v3", 0);
        }
        return 0;
    }

    public static boolean wu() {
        return fm("jsb_opt_enable", 0) == 1;
    }

    public static boolean yz() {
        return lb() && fm("ad_load_and_render_opt", "thread_switch_opt", 0) == 1;
    }

    public static String fm() {
        lb lbVarRo;
        SharedPreferences sharedPreferencesFm;
        try {
            yz yzVarDuv = duv();
            if (yzVarDuv == null || (lbVarRo = yzVarDuv.ro()) == null || (sharedPreferencesFm = lbVarRo.fm()) == null) {
                return null;
            }
            return new JSONObject(sharedPreferencesFm.getAll()).toString();
        } catch (Exception e10) {
            wey.fm("StrategyUtils", "getStrategyConfig error", e10);
            return null;
        }
    }

    public static int fm(String str, int i10) {
        yz yzVarDuv = duv();
        return yzVarDuv != null ? yzVarDuv.fm(str, i10) : i10;
    }

    public static boolean fm(String str, boolean z10) {
        yz yzVarDuv = duv();
        return yzVarDuv != null ? yzVarDuv.fm(str, z10) : z10;
    }

    public static String fm(String str, String str2) {
        yz yzVarDuv = duv();
        return yzVarDuv != null ? yzVarDuv.fm(str, str2) : str2;
    }

    public static <T> T fm(String str, T t10, ro.fm<T> fmVar) {
        yz yzVarDuv = duv();
        return yzVarDuv != null ? (T) yzVarDuv.fm(str, t10, fmVar) : t10;
    }

    public static int fm(String str, String str2, int i10) {
        if (!TextUtils.isEmpty(str) && !TextUtils.isEmpty(str2)) {
            String strJ = e.j(str, "_", str2);
            ConcurrentHashMap<String, Object> concurrentHashMap = fm;
            Object obj = concurrentHashMap.get(strJ);
            if (obj != null && (obj instanceof Integer)) {
                return ((Integer) obj).intValue();
            }
            try {
                String strFm = duv().fm(str, "");
                if (TextUtils.isEmpty(strFm)) {
                    return i10;
                }
                int iOptInt = new JSONObject(strFm).optInt(str2, i10);
                concurrentHashMap.put(strJ, Integer.valueOf(iOptInt));
                return iOptInt;
            } catch (Throwable th) {
                wey.lb("StrategyUtils", th.getMessage());
            }
        }
        return i10;
    }

    public static String fm(String str, String str2, String str3) {
        if (!TextUtils.isEmpty(str) && !TextUtils.isEmpty(str2)) {
            String strJ = e.j(str, "_", str2);
            ConcurrentHashMap<String, Object> concurrentHashMap = fm;
            Object obj = concurrentHashMap.get(strJ);
            if (obj != null && (obj instanceof String)) {
                return (String) obj;
            }
            try {
                String strFm = duv().fm(str, "");
                if (TextUtils.isEmpty(strFm)) {
                    return str3;
                }
                String strOptString = new JSONObject(strFm).optString(str2, str3);
                concurrentHashMap.put(strJ, strOptString);
                return strOptString;
            } catch (Throwable th) {
                wey.lb("StrategyUtils", th.getMessage());
            }
        }
        return str3;
    }

    private static int fm(String str) {
        JSONObject jSONObject = (JSONObject) fm("rviv_close_button_backup", (Object) null, ro.fm);
        if (TextUtils.isEmpty(str) || jSONObject == null) {
            return -1;
        }
        try {
            Object obj = jSONObject.get(str);
            if (obj instanceof Number) {
                return ((Number) obj).intValue();
            }
            return -1;
        } catch (JSONException e10) {
            e10.getMessage();
            return -1;
        }
    }

    public static int fm(com.bytedance.sdk.openadsdk.component.reward.fm.ro roVar) {
        if (roVar == null) {
            return -1;
        }
        if (roVar.pbk) {
            com.bytedance.sdk.openadsdk.activity.single.wu wuVar = roVar.zow;
            if (!(wuVar instanceof com.bytedance.sdk.openadsdk.activity.single.jnr)) {
                return -1;
            }
            if (((com.bytedance.sdk.openadsdk.activity.single.jnr) wuVar).fm) {
                return fm("one_more_mutlti_endcard");
            }
            com.bytedance.sdk.openadsdk.component.reward.fm.gof gofVar = roVar.ol;
            if (gofVar == null || !gofVar.wey()) {
                return -1;
            }
            return fm("one_more_mutlti_double_endcard");
        }
        if (ai.ro(roVar.ro)) {
            if (ai.wu(roVar.ro)) {
                return fm("playable_link_endcard");
            }
            if (ai.ajl(roVar.ro)) {
                return fm("pure_playable");
            }
            return fm("playable");
        }
        com.bytedance.sdk.openadsdk.component.reward.fm.gof gofVar2 = roVar.ol;
        if (gofVar2 != null && gofVar2.wey()) {
            return fm("double_endcard");
        }
        if (!com.bytedance.sdk.openadsdk.core.model.wey.yz(roVar.ro) && !com.bytedance.sdk.openadsdk.core.model.wey.ro(roVar.ro) && !com.bytedance.sdk.openadsdk.core.model.wey.wu(roVar.ro)) {
            return fm("endcard");
        }
        return fm("direct_landingpage");
    }
}