package com.parse;

import android.content.Context;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import p138.p176.p177.p242.p246.p251.C4303;

/* JADX INFO: loaded from: classes.dex */
public class ParseKeyValueCache {
    public static final Object MUTEX_IO = new Object();
    public static File directory;

    public static void clearFromKeyValueCache(String str) {
        synchronized (MUTEX_IO) {
            File keyValueCacheFile = getKeyValueCacheFile(str);
            if (keyValueCacheFile != null) {
                keyValueCacheFile.delete();
            }
        }
    }

    public static File getKeyValueCacheDir() {
        File file = directory;
        if (file != null && !file.exists()) {
            directory.mkdir();
        }
        return directory;
    }

    public static File getKeyValueCacheFile(String str) {
        final String str2 = '.' + str;
        File[] fileArrListFiles = getKeyValueCacheDir().listFiles(new FilenameFilter() { // from class: com.parse.ParseKeyValueCache.1
            @Override // java.io.FilenameFilter
            public boolean accept(File file, String str3) {
                return str3.endsWith(str2);
            }
        });
        if (fileArrListFiles == null || fileArrListFiles.length == 0) {
            return null;
        }
        return fileArrListFiles[0];
    }

    public static void initialize(Context context) {
        File file = new File(context.getCacheDir(), "ParseKeyValueCache");
        if (!file.isDirectory() && !file.mkdir()) {
            throw new RuntimeException("Could not create ParseKeyValueCache directory");
        }
        directory = file;
    }

    public static String loadFromKeyValueCache(String str, long j) {
        synchronized (MUTEX_IO) {
            File keyValueCacheFile = getKeyValueCacheFile(str);
            if (keyValueCacheFile == null) {
                return null;
            }
            Date date = new Date();
            long time = date.getTime() - j;
            long j2 = 0;
            long jMax = Math.max(0L, time);
            String name = keyValueCacheFile.getName();
            try {
                j2 = Long.parseLong(name.substring(0, name.indexOf(46)));
            } catch (NumberFormatException unused) {
            }
            if (j2 < jMax) {
                return null;
            }
            keyValueCacheFile.setLastModified(date.getTime());
            try {
                RandomAccessFile randomAccessFile = new RandomAccessFile(keyValueCacheFile, "r");
                byte[] bArr = new byte[(int) randomAccessFile.length()];
                randomAccessFile.readFully(bArr);
                randomAccessFile.close();
                return new String(bArr, "UTF-8");
            } catch (IOException e) {
                PLog.log(6, "ParseKeyValueCache", "error reading from cache", e);
                return null;
            }
        }
    }

    public static void saveToKeyValueCache(String str, String str2) {
        synchronized (MUTEX_IO) {
            File keyValueCacheFile = getKeyValueCacheFile(str);
            if (keyValueCacheFile != null) {
                keyValueCacheFile.delete();
            }
            try {
                C4303.writeByteArrayToFile(new File(getKeyValueCacheDir(), String.valueOf(new Date().getTime()) + '.' + str), str2.getBytes("UTF-8"));
            } catch (IOException unused) {
            }
            File[] fileArrListFiles = getKeyValueCacheDir().listFiles();
            if (fileArrListFiles != null && fileArrListFiles.length != 0) {
                int length = fileArrListFiles.length;
                int length2 = 0;
                for (File file : fileArrListFiles) {
                    length2 = (int) (((long) length2) + file.length());
                }
                if (length > 1000 || length2 > 2097152) {
                    Arrays.sort(fileArrListFiles, new Comparator<File>() { // from class: com.parse.ParseKeyValueCache.2
                        @Override // java.util.Comparator
                        public int compare(File file2, File file3) {
                            File file4 = file2;
                            File file5 = file3;
                            int iCompareTo = Long.valueOf(file4.lastModified()).compareTo(Long.valueOf(file5.lastModified()));
                            return iCompareTo != 0 ? iCompareTo : file4.getName().compareTo(file5.getName());
                        }
                    });
                    for (File file2 : fileArrListFiles) {
                        length--;
                        length2 = (int) (((long) length2) - file2.length());
                        file2.delete();
                        if (length <= 1000 && length2 <= 2097152) {
                            break;
                        }
                    }
                }
            }
        }
    }
}