package tv.danmaku.ijk.media.player.ui;

import android.content.Context;
import android.content.SharedPreferences;
import androidx.media3.exoplayer.rtsp.SessionDescription;
import okhttp3.OkHttpClient;

/* JADX INFO: loaded from: classes3.dex */
public final class IjkPlayerRuntime {
    private static final String LIVE_AUDIO_PREFIX = "live_audio_";
    public static final String SP_AUDIO = "flutter.spAudioLanguage";
    public static final String SP_HISTORY_BITRATE = "sp_history_bitrate";
    public static final String SP_LANGUAGE = "sp_language";
    public static final String SP_LIVE_BITRATE = "sp_live_bitrate";
    public static final String SP_LIVE_SUBTITLE = "sp_live_subtitle";
    public static final String SP_LIVE_SUBTITLE_ENABLE = "sp_live_subtitle_enable";
    public static final String SP_SUBTITLE_SIZE = "sp_subtitle_size";
    public static final String SP_VOD_VIDEO_RATIO = "sp_vod_video_ratio";
    public static final int SUBTITLE_SIZE_MEDIUM = 50;
    private static final String TAG = "XyzStream";
    private static volatile Config config = new Config(null, null, null, null, null);
    private static volatile OkHttpClient fallbackClient;

    public interface AudioLanguageProvider {
        String getAudioLanguage();

        String getDefaultAudioShortLanguage();
    }

    public static final class Builder {
        private AudioLanguageProvider audioLanguageProvider;
        private final Context context;
        private OkHttpClient okHttpClient;
        private PremiumUserProvider premiumUserProvider;
        private SharedPreferences sharedPreferences;

        public /* synthetic */ Builder(Context context, int i10) {
            this(context);
        }

        public Builder audioLanguageProvider(AudioLanguageProvider audioLanguageProvider) {
            this.audioLanguageProvider = audioLanguageProvider;
            return this;
        }

        public void build() {
            if (this.context != null) {
                CacheManager.getInstance().init(this.context);
            }
            IjkPlayerRuntime.config = new Config(this.context, this.okHttpClient, this.sharedPreferences, this.audioLanguageProvider, this.premiumUserProvider);
        }

        public Builder okHttpClient(OkHttpClient okHttpClient) {
            this.okHttpClient = okHttpClient;
            return this;
        }

        public Builder premiumUserProvider(PremiumUserProvider premiumUserProvider) {
            this.premiumUserProvider = premiumUserProvider;
            return this;
        }

        public Builder sharedPreferences(SharedPreferences sharedPreferences) {
            this.sharedPreferences = sharedPreferences;
            return this;
        }

        private Builder(Context context) {
            this.context = context == null ? null : context.getApplicationContext();
        }
    }

    public static final class Config {
        final AudioLanguageProvider audioLanguageProvider;
        final Context context;
        final OkHttpClient okHttpClient;
        final PremiumUserProvider premiumUserProvider;
        final SharedPreferences sharedPreferences;

        public Config(Context context, OkHttpClient okHttpClient, SharedPreferences sharedPreferences, AudioLanguageProvider audioLanguageProvider, PremiumUserProvider premiumUserProvider) {
            this.context = context;
            this.okHttpClient = okHttpClient;
            this.sharedPreferences = sharedPreferences;
            this.audioLanguageProvider = audioLanguageProvider;
            this.premiumUserProvider = premiumUserProvider;
        }
    }

    public interface PremiumUserProvider {
        boolean isPremiumUser();
    }

    private IjkPlayerRuntime() {
    }

    public static Builder builder(Context context) {
        return new Builder(context, 0);
    }

    public static String getAudioLanguage() {
        AudioLanguageProvider audioLanguageProvider = config.audioLanguageProvider;
        if (audioLanguageProvider != null) {
            try {
                String audioLanguage = audioLanguageProvider.getAudioLanguage();
                if (audioLanguage != null) {
                    return audioLanguage;
                }
            } catch (Exception e10) {
                logError("getAudioLanguage error: " + e10.getMessage());
            }
        }
        String string = readString(SP_AUDIO, null);
        if (string == null || string.isEmpty() || string.equalsIgnoreCase("original")) {
            return "original";
        }
        if (string.equalsIgnoreCase("Others")) {
            return "other";
        }
        return null;
    }

    public static String getDefaultAudioShortLanguage() {
        AudioLanguageProvider audioLanguageProvider = config.audioLanguageProvider;
        if (audioLanguageProvider != null) {
            try {
                String defaultAudioShortLanguage = audioLanguageProvider.getDefaultAudioShortLanguage();
                if (defaultAudioShortLanguage != null) {
                    return defaultAudioShortLanguage;
                }
            } catch (Exception e10) {
                logError("getDefaultAudioShortLanguage error: " + e10.getMessage());
            }
        }
        String string = readString(SP_AUDIO, null);
        if (string == null) {
            string = readString(SP_LANGUAGE, null);
        }
        return toShortLanguage(string);
    }

    public static String getHistoryBitrate() {
        return readString(SP_HISTORY_BITRATE, SessionDescription.SUPPORTED_SDP_VERSION);
    }

    public static String getLiveAudio(String str) {
        if (str == null) {
            return null;
        }
        return readString(LIVE_AUDIO_PREFIX.concat(str), null);
    }

    public static int getLiveBitrate(int i10) {
        return readInt(SP_LIVE_BITRATE, i10);
    }

    public static String getLiveSubtitle() {
        return readString(SP_LIVE_SUBTITLE, null);
    }

    public static OkHttpClient getOkHttpClient() {
        OkHttpClient okHttpClient = config.okHttpClient;
        if (okHttpClient != null) {
            return okHttpClient;
        }
        if (fallbackClient == null) {
            synchronized (IjkPlayerRuntime.class) {
                try {
                    if (fallbackClient == null) {
                        fallbackClient = new OkHttpClient();
                    }
                } finally {
                }
            }
        }
        return fallbackClient;
    }

    public static int getSubtitleSize() {
        return readInt(SP_SUBTITLE_SIZE, 50);
    }

    public static int getVodVideoRatio(int i10) {
        return readInt(SP_VOD_VIDEO_RATIO, i10);
    }

    public static boolean isLiveSubtitleEnabled() {
        return readBoolean(SP_LIVE_SUBTITLE_ENABLE, true);
    }

    public static boolean isPremiumUser() {
        PremiumUserProvider premiumUserProvider = config.premiumUserProvider;
        if (premiumUserProvider == null) {
            return false;
        }
        try {
            return premiumUserProvider.isPremiumUser();
        } catch (Exception e10) {
            logError("isPremiumUser error: " + e10.getMessage());
            return false;
        }
    }

    public static void logDebug(String str) {
        safeMessage(str);
    }

    public static void logError(String str) {
        safeMessage(str);
    }

    private static boolean readBoolean(String str, boolean z10) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null) {
            return z10;
        }
        try {
            return sharedPreferences.getBoolean(str, z10);
        } catch (Exception e10) {
            logError("readBoolean error: " + e10.getMessage());
            return z10;
        }
    }

    private static int readInt(String str, int i10) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null) {
            return i10;
        }
        try {
            return sharedPreferences.getInt(str, i10);
        } catch (Exception e10) {
            logError("readInt error: " + e10.getMessage());
            return i10;
        }
    }

    private static String readString(String str, String str2) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null) {
            return str2;
        }
        try {
            return sharedPreferences.getString(str, str2);
        } catch (Exception e10) {
            logError("readString error: " + e10.getMessage());
            return str2;
        }
    }

    public static Context requireApplicationContext() {
        Context context = config.context;
        if (context != null) {
            return context;
        }
        throw new IllegalStateException("IjkPlayerRuntime has not been initialized");
    }

    private static String safeMessage(String str) {
        return str == null ? "null" : str;
    }

    public static void saveLog(String str) {
        saveLog(TAG, str);
    }

    public static void setHistoryBitrate(String str) {
        writeString(SP_HISTORY_BITRATE, str);
    }

    public static void setLiveAudio(String str, String str2) {
        if (str == null) {
            return;
        }
        writeString(LIVE_AUDIO_PREFIX.concat(str), str2);
    }

    public static void setLiveBitrate(int i10) {
        writeInt(SP_LIVE_BITRATE, i10);
    }

    public static void setLiveSubtitle(String str) {
        writeString(SP_LIVE_SUBTITLE, str);
    }

    public static String toShortLanguage(String str) {
        if (str == null || str.isEmpty()) {
            return null;
        }
        if (str.contains("English") || str.contains("en-US") || str.equalsIgnoreCase("en")) {
            return "en";
        }
        String str2 = "pt";
        if (!str.contains("Português") && !str.contains("pt-BR") && !str.equalsIgnoreCase("pt")) {
            str2 = "es";
            if (!str.contains("Español") && !str.contains("es-ES") && !str.equalsIgnoreCase("es")) {
                str2 = "ar";
                if (!str.contains("بالعربية") && !str.contains("ar") && !str.equalsIgnoreCase("ar")) {
                    str2 = "fr";
                    if (!str.contains("Français") && !str.contains("fr-FR") && !str.equalsIgnoreCase("fr")) {
                        str2 = "tr";
                        if (!str.contains("Türkçe") && !str.contains("tr-TR") && !str.equalsIgnoreCase("tr")) {
                            return "en";
                        }
                    }
                }
            }
        }
        return str2;
    }

    private static void writeBoolean(String str, boolean z10) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null) {
            return;
        }
        try {
            sharedPreferences.edit().putBoolean(str, z10).apply();
        } catch (Exception e10) {
            logError("writeBoolean error: " + e10.getMessage());
        }
    }

    private static void writeInt(String str, int i10) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null) {
            return;
        }
        try {
            sharedPreferences.edit().putInt(str, i10).apply();
        } catch (Exception e10) {
            logError("writeInt error: " + e10.getMessage());
        }
    }

    private static void writeString(String str, String str2) {
        SharedPreferences sharedPreferences = config.sharedPreferences;
        if (sharedPreferences == null || str == null) {
            return;
        }
        try {
            sharedPreferences.edit().putString(str, str2).apply();
        } catch (Exception e10) {
            logError("writeString error: " + e10.getMessage());
        }
    }

    public static void saveLog(String str, String str2) {
        safeMessage(str2);
    }
}