package com.tencent.mmkv;

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;
import dalvik.annotation.optimization.FastNative;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import q6.EnumC1479a;
import q6.EnumC1480b;

/* JADX INFO: loaded from: classes.dex */
public class MMKV implements SharedPreferences, SharedPreferences.Editor {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final EnumMap f11249a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final EnumMap f11250b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final EnumC1479a[] f11251c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final HashSet f11252d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static String f11253e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public static boolean f11254f;
    private final long nativeHandle;

    static {
        EnumMap enumMap = new EnumMap(EnumC1480b.class);
        f11249a = enumMap;
        enumMap.put(EnumC1480b.f16326q, 0);
        enumMap.put(EnumC1480b.f16327r, 1);
        EnumMap enumMap2 = new EnumMap(EnumC1479a.class);
        f11250b = enumMap2;
        EnumC1479a enumC1479a = EnumC1479a.f16320q;
        enumMap2.put(enumC1479a, 0);
        EnumC1479a enumC1479a2 = EnumC1479a.f16321r;
        enumMap2.put(enumC1479a2, 1);
        EnumC1479a enumC1479a3 = EnumC1479a.f16322s;
        enumMap2.put(enumC1479a3, 2);
        EnumC1479a enumC1479a4 = EnumC1479a.f16323t;
        enumMap2.put(enumC1479a4, 3);
        EnumC1479a enumC1479a5 = EnumC1479a.f16324u;
        enumMap2.put(enumC1479a5, 4);
        f11251c = new EnumC1479a[]{enumC1479a, enumC1479a2, enumC1479a3, enumC1479a4, enumC1479a5};
        f11252d = new HashSet();
        f11253e = null;
        f11254f = true;
        new HashMap();
    }

    public MMKV(long j8) {
        this.nativeHandle = j8;
    }

    public static MMKV a() {
        if (f11253e == null) {
            throw new IllegalStateException("You should Call MMKV.initialize() first.");
        }
        long defaultMMKV = getDefaultMMKV(1, null);
        if (defaultMMKV == 0) {
            throw new RuntimeException("Fail to create an MMKV instance [DefaultMMKV] in JNI");
        }
        if (!f11254f) {
            return new MMKV(defaultMMKV);
        }
        HashSet hashSet = f11252d;
        synchronized (hashSet) {
            try {
                if (!hashSet.contains(Long.valueOf(defaultMMKV))) {
                    if (!checkProcessMode(defaultMMKV)) {
                        throw new IllegalArgumentException("Opening a multi-process MMKV instance [DefaultMMKV] with SINGLE_PROCESS_MODE!");
                    }
                    hashSet.add(Long.valueOf(defaultMMKV));
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        return new MMKV(defaultMMKV);
    }

    private native long actualSize(long j8);

    private native String[] allKeys(long j8, boolean z8);

    public static void b() {
        synchronized (f11252d) {
            f11254f = true;
        }
        Log.i("MMKV", "Enable checkProcessMode()");
    }

    public static native long backupAllToDirectory(String str);

    public static native boolean backupOneToDirectory(String str, String str2, String str3);

    private static native boolean checkProcessMode(long j8);

    private native boolean containsKey(long j8, String str);

    private native long count(long j8, boolean z8);

    private static native long createNB(int i);

    public static void d(Context context) {
        String str = context.getFilesDir().getAbsolutePath() + "/mmkv";
        if ((context.getApplicationInfo().flags & 2) == 0) {
            synchronized (f11252d) {
                f11254f = false;
            }
            Log.i("MMKV", "Disable checkProcessMode()");
        } else {
            b();
        }
        String absolutePath = context.getCacheDir().getAbsolutePath();
        System.loadLibrary("mmkv");
        jniInitialize(str, absolutePath, 4, false);
        f11253e = str;
    }

    private native boolean decodeBool(long j8, String str, boolean z8);

    private native byte[] decodeBytes(long j8, String str);

    private native double decodeDouble(long j8, String str, double d8);

    private native float decodeFloat(long j8, String str, float f3);

    private native int decodeInt(long j8, String str, int i);

    private native long decodeLong(long j8, String str, long j9);

    private native String decodeString(long j8, String str, String str2);

    private native String[] decodeStringSet(long j8, String str);

    private static native void destroyNB(long j8, int i);

    private native boolean encodeBool(long j8, String str, boolean z8);

    private native boolean encodeBool_2(long j8, String str, boolean z8, int i);

    private native boolean encodeBytes(long j8, String str, byte[] bArr);

    private native boolean encodeBytes_2(long j8, String str, byte[] bArr, int i);

    private native boolean encodeDouble(long j8, String str, double d8);

    private native boolean encodeDouble_2(long j8, String str, double d8, int i);

    private native boolean encodeFloat(long j8, String str, float f3);

    private native boolean encodeFloat_2(long j8, String str, float f3, int i);

    private native boolean encodeInt(long j8, String str, int i);

    private native boolean encodeInt_2(long j8, String str, int i, int i5);

    private native boolean encodeLong(long j8, String str, long j9);

    private native boolean encodeLong_2(long j8, String str, long j9, int i);

    private native boolean encodeSet(long j8, String str, String[] strArr);

    private native boolean encodeSet_2(long j8, String str, String[] strArr, int i);

    private native boolean encodeString(long j8, String str, String str2);

    private native boolean encodeString_2(long j8, String str, String str2, int i);

    public static void f(String str) {
        EnumC1479a enumC1479a = EnumC1479a.f16321r;
        StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[r1.length - 1];
        Integer num = (Integer) f11250b.get(enumC1479a);
        mmkvLogImp(num == null ? 0 : num.intValue(), stackTraceElement.getFileName(), stackTraceElement.getLineNumber(), stackTraceElement.getMethodName(), str);
    }

    private static native long getDefaultMMKV(int i, String str);

    private static native long getMMKVWithAshmemFD(String str, int i, int i5, String str2);

    private static native long getMMKVWithID(String str, int i, String str2, String str3, long j8);

    private static native long getMMKVWithIDAndSize(String str, int i, int i5, String str2);

    private native boolean isCompareBeforeSetEnabled();

    @FastNative
    private native boolean isEncryptionEnabled();

    @FastNative
    private native boolean isExpirationEnabled();

    public static native boolean isFileValid(String str, String str2);

    private static native void jniInitialize(String str, String str2, int i, boolean z8);

    private static void mmkvLogImp(int i, String str, int i5, String str2, String str3) {
        int iOrdinal = f11251c[i].ordinal();
        if (iOrdinal == 0) {
            Log.d("MMKV", str3);
            return;
        }
        if (iOrdinal == 1) {
            Log.i("MMKV", str3);
        } else if (iOrdinal == 2) {
            Log.w("MMKV", str3);
        } else {
            if (iOrdinal != 3) {
                return;
            }
            Log.e("MMKV", str3);
        }
    }

    @FastNative
    private native void nativeEnableCompareBeforeSet();

    private static void onContentChangedByOuterProcess(String str) {
    }

    public static native void onExit();

    private static int onMMKVCRCCheckFail(String str) {
        EnumC1480b enumC1480b = EnumC1480b.f16326q;
        f("Recover strategic for " + str + " is " + enumC1480b);
        Integer num = (Integer) f11249a.get(enumC1480b);
        if (num == null) {
            return 0;
        }
        return num.intValue();
    }

    private static int onMMKVFileLengthError(String str) {
        EnumC1480b enumC1480b = EnumC1480b.f16326q;
        f("Recover strategic for " + str + " is " + enumC1480b);
        Integer num = (Integer) f11249a.get(enumC1480b);
        if (num == null) {
            return 0;
        }
        return num.intValue();
    }

    public static native int pageSize();

    public static native boolean removeStorage(String str, String str2);

    private native void removeValueForKey(long j8, String str);

    public static native long restoreAllFromDirectory(String str);

    public static native boolean restoreOneMMKVFromDirectory(String str, String str2, String str3);

    private static native void setCallbackHandler(boolean z8, boolean z9);

    private static native void setLogLevel(int i);

    private static native void setWantsContentChangeNotify(boolean z8);

    private native void sync(boolean z8);

    private native long totalSize(long j8);

    private native int valueSize(long j8, String str, boolean z8);

    public static native String version();

    private native int writeValueToNB(long j8, String str, long j9, int i);

    @Override // android.content.SharedPreferences.Editor
    public final void apply() {
        sync(false);
    }

    public native int ashmemFD();

    public native int ashmemMetaFD();

    public final byte[] c(String str, byte[] bArr) {
        byte[] bArrDecodeBytes = decodeBytes(this.nativeHandle, str);
        return bArrDecodeBytes != null ? bArrDecodeBytes : bArr;
    }

    public native void checkContentChangedByOuterProcess();

    public native void checkReSetCryptKey(String str);

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor clear() {
        clearAll();
        return this;
    }

    public native void clearAll();

    public native void clearAllWithKeepingSpace();

    public native void clearMemoryCache();

    public native void close();

    @Override // android.content.SharedPreferences.Editor
    public final boolean commit() {
        sync(true);
        return true;
    }

    @Override // android.content.SharedPreferences
    public final boolean contains(String str) {
        return containsKey(this.nativeHandle, str);
    }

    public native String cryptKey();

    public native boolean disableAutoKeyExpire();

    public native void disableCompareBeforeSet();

    public final void e(String str, byte[] bArr) {
        encodeBytes(this.nativeHandle, str, bArr);
    }

    @Override // android.content.SharedPreferences
    public final SharedPreferences.Editor edit() {
        return this;
    }

    public native boolean enableAutoKeyExpire(int i);

    @Override // android.content.SharedPreferences
    public final Map getAll() {
        throw new UnsupportedOperationException("Intentionally Not Supported. Use allKeys() instead, getAll() not implement because type-erasure inside mmkv");
    }

    @Override // android.content.SharedPreferences
    public final boolean getBoolean(String str, boolean z8) {
        return decodeBool(this.nativeHandle, str, z8);
    }

    @Override // android.content.SharedPreferences
    public final float getFloat(String str, float f3) {
        return decodeFloat(this.nativeHandle, str, f3);
    }

    @Override // android.content.SharedPreferences
    public final int getInt(String str, int i) {
        return decodeInt(this.nativeHandle, str, i);
    }

    @Override // android.content.SharedPreferences
    public final long getLong(String str, long j8) {
        return decodeLong(this.nativeHandle, str, j8);
    }

    @Override // android.content.SharedPreferences
    public final String getString(String str, String str2) {
        return decodeString(this.nativeHandle, str, str2);
    }

    @Override // android.content.SharedPreferences
    public final Set getStringSet(String str, Set set) {
        String[] strArrDecodeStringSet = decodeStringSet(this.nativeHandle, str);
        if (strArrDecodeStringSet != null) {
            try {
                Set set2 = (Set) HashSet.class.newInstance();
                set2.addAll(Arrays.asList(strArrDecodeStringSet));
                return set2;
            } catch (IllegalAccessException | InstantiationException unused) {
            }
        }
        return set;
    }

    public native void lock();

    public native String mmapID();

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putBoolean(String str, boolean z8) {
        encodeBool(this.nativeHandle, str, z8);
        return this;
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putFloat(String str, float f3) {
        encodeFloat(this.nativeHandle, str, f3);
        return this;
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putInt(String str, int i) {
        encodeInt(this.nativeHandle, str, i);
        return this;
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putLong(String str, long j8) {
        encodeLong(this.nativeHandle, str, j8);
        return this;
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putString(String str, String str2) {
        encodeString(this.nativeHandle, str, str2);
        return this;
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor putStringSet(String str, Set set) {
        encodeSet(this.nativeHandle, str, set == null ? null : (String[]) set.toArray(new String[0]));
        return this;
    }

    public native boolean reKey(String str);

    @Override // android.content.SharedPreferences
    public final void registerOnSharedPreferenceChangeListener(SharedPreferences.OnSharedPreferenceChangeListener onSharedPreferenceChangeListener) {
        throw new UnsupportedOperationException("Intentionally Not implement in MMKV");
    }

    @Override // android.content.SharedPreferences.Editor
    public final SharedPreferences.Editor remove(String str) {
        removeValueForKey(this.nativeHandle, str);
        return this;
    }

    public native void removeValuesForKeys(String[] strArr);

    public native void trim();

    public native boolean tryLock();

    public native void unlock();

    @Override // android.content.SharedPreferences
    public final void unregisterOnSharedPreferenceChangeListener(SharedPreferences.OnSharedPreferenceChangeListener onSharedPreferenceChangeListener) {
        throw new UnsupportedOperationException("Intentionally Not implement in MMKV");
    }
}