package com.duoyou.task.sdk.xutils.cache;
import android.text.TextUtils;
import com.duoyou.task.sdk.xutils.DbManager;
import com.duoyou.task.sdk.xutils.common.task.PriorityExecutor;
import com.duoyou.task.sdk.xutils.common.util.FileUtil;
import com.duoyou.task.sdk.xutils.common.util.IOUtil;
import com.duoyou.task.sdk.xutils.common.util.LogUtil;
import com.duoyou.task.sdk.xutils.common.util.MD5;
import com.duoyou.task.sdk.xutils.common.util.ProcessLock;
import com.duoyou.task.sdk.xutils.config.DbConfigs;
import com.duoyou.task.sdk.xutils.db.sqlite.WhereBuilder;
import com.duoyou.task.sdk.xutils.ex.FileLockedException;
import com.duoyou.task.sdk.xutils.x;
import com.kwai.video.player.NativeErrorCode;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Executor;
public final class LruDiskCache {
private static final String CACHE_DIR_NAME = "xUtils_cache";
private static final HashMap<String, LruDiskCache> DISK_CACHE_MAP = new HashMap<>(5);
private static final int LIMIT_COUNT = 5000;
private static final long LIMIT_SIZE = 104857600;
private static final int LOCK_WAIT = 3000;
private static final String TEMP_FILE_SUFFIX = ".tmp";
private static final long TRIM_TIME_SPAN = 1000;
private boolean available = false;
private DbManager cacheDb;
private File cacheDir;
private long diskCacheSize = LIMIT_SIZE;
private long lastTrimTime = 0;
private final Executor trimExecutor = new PriorityExecutor(1, true);
private LruDiskCache(String str) {
try {
File cacheDir2 = FileUtil.getCacheDir(str);
this.cacheDir = cacheDir2;
if (cacheDir2 != null && (cacheDir2.exists() || this.cacheDir.mkdirs())) {
this.available = true;
}
this.cacheDb = x.getDb(DbConfigs.HTTP.getConfig());
} catch (Throwable th) {
this.available = false;
LogUtil.e(th.getMessage(), th);
}
deleteNoIndexFiles();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void deleteExpiry() {
if (this.available) {
try {
WhereBuilder b = WhereBuilder.b("expires", "<", Long.valueOf(System.currentTimeMillis()));
List<DiskCacheEntity> findAll = this.cacheDb.selector(DiskCacheEntity.class).where(b).findAll();
this.cacheDb.delete(DiskCacheEntity.class, b);
if (findAll != null && findAll.size() > 0) {
for (DiskCacheEntity diskCacheEntity : findAll) {
String path = diskCacheEntity.getPath();
if (!TextUtils.isEmpty(path)) {
deleteFileWithLock(path);
}
}
}
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private boolean deleteFileWithLock(String str) {
Throwable th;
ProcessLock processLock;
try {
processLock = ProcessLock.tryLock(str, true);
if (processLock != null) {
try {
if (processLock.isValid()) {
boolean deleteFileOrDir = IOUtil.deleteFileOrDir(new File(str));
IOUtil.closeQuietly(processLock);
return deleteFileOrDir;
}
} catch (Throwable th2) {
th = th2;
IOUtil.closeQuietly(processLock);
throw th;
}
}
IOUtil.closeQuietly(processLock);
return false;
} catch (Throwable th3) {
th = th3;
processLock = null;
IOUtil.closeQuietly(processLock);
throw th;
}
}
private void deleteNoIndexFiles() {
this.trimExecutor.execute(new Runnable() {
/* class com.duoyou.task.sdk.xutils.cache.LruDiskCache.AnonymousClass3 */
public void run() {
if (LruDiskCache.this.available) {
try {
File[] listFiles = LruDiskCache.this.cacheDir.listFiles();
if (listFiles != null) {
for (File file : listFiles) {
try {
if (LruDiskCache.this.cacheDb.selector(DiskCacheEntity.class).where("path", "=", file.getAbsolutePath()).count() < 1) {
IOUtil.deleteFileOrDir(file);
}
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
}
}
}
} catch (Throwable th2) {
LogUtil.e(th2.getMessage(), th2);
}
}
}
});
}
public static synchronized LruDiskCache getDiskCache(String str) {
LruDiskCache lruDiskCache;
synchronized (LruDiskCache.class) {
if (TextUtils.isEmpty(str)) {
str = CACHE_DIR_NAME;
}
HashMap<String, LruDiskCache> hashMap = DISK_CACHE_MAP;
lruDiskCache = hashMap.get(str);
if (lruDiskCache == null) {
lruDiskCache = new LruDiskCache(str);
hashMap.put(str, lruDiskCache);
}
}
return lruDiskCache;
}
private void trimSize() {
this.trimExecutor.execute(new Runnable() {
/* class com.duoyou.task.sdk.xutils.cache.LruDiskCache.AnonymousClass2 */
public void run() {
List<DiskCacheEntity> findAll;
if (LruDiskCache.this.available) {
long currentTimeMillis = System.currentTimeMillis();
if (currentTimeMillis - LruDiskCache.this.lastTrimTime >= 1000) {
LruDiskCache.this.lastTrimTime = currentTimeMillis;
LruDiskCache.this.deleteExpiry();
try {
int count = (int) LruDiskCache.this.cacheDb.selector(DiskCacheEntity.class).count();
if (count > 5010 && (findAll = LruDiskCache.this.cacheDb.selector(DiskCacheEntity.class).orderBy("lastAccess").orderBy("hits").limit(count + NativeErrorCode.EKS_FFMPEG_ERROR_BASE).offset(0).findAll()) != null && findAll.size() > 0) {
for (DiskCacheEntity diskCacheEntity : findAll) {
try {
LruDiskCache.this.cacheDb.delete(diskCacheEntity);
String path = diskCacheEntity.getPath();
if (!TextUtils.isEmpty(path)) {
LruDiskCache.this.deleteFileWithLock(path);
LruDiskCache lruDiskCache = LruDiskCache.this;
lruDiskCache.deleteFileWithLock(path + ".tmp");
}
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
}
}
}
} catch (Throwable th2) {
LogUtil.e(th2.getMessage(), th2);
}
while (FileUtil.getFileOrDirSize(LruDiskCache.this.cacheDir) > LruDiskCache.this.diskCacheSize) {
try {
List<DiskCacheEntity> findAll2 = LruDiskCache.this.cacheDb.selector(DiskCacheEntity.class).orderBy("lastAccess").orderBy("hits").limit(10).offset(0).findAll();
if (findAll2 != null && findAll2.size() > 0) {
for (DiskCacheEntity diskCacheEntity2 : findAll2) {
try {
LruDiskCache.this.cacheDb.delete(diskCacheEntity2);
String path2 = diskCacheEntity2.getPath();
if (!TextUtils.isEmpty(path2)) {
LruDiskCache.this.deleteFileWithLock(path2);
LruDiskCache lruDiskCache2 = LruDiskCache.this;
lruDiskCache2.deleteFileWithLock(path2 + ".tmp");
}
} catch (Throwable th3) {
LogUtil.e(th3.getMessage(), th3);
}
}
}
} catch (Throwable th4) {
LogUtil.e(th4.getMessage(), th4);
return;
}
}
}
}
}
});
}
public void clearCacheFiles() {
IOUtil.deleteFileOrDir(this.cacheDir);
}
/* JADX WARNING: Code restructure failed: missing block: B:23:0x0050, code lost:
r0 = th;
*/
/* JADX WARNING: Code restructure failed: missing block: B:24:0x0051, code lost:
r1 = r4;
*/
/* JADX WARNING: Code restructure failed: missing block: B:28:0x0070, code lost:
r0 = e;
*/
/* JADX WARNING: Code restructure failed: missing block: B:29:0x0071, code lost:
r1 = r4;
*/
/* JADX WARNING: Failed to process nested try/catch */
/* JADX WARNING: Removed duplicated region for block: B:28:0x0070 A[ExcHandler: InterruptedException (e java.lang.InterruptedException), Splitter:B:13:0x0031] */
/* JADX WARNING: Removed duplicated region for block: B:45:0x0096 */
/* JADX WARNING: Removed duplicated region for block: B:46:0x00a0 */
public DiskCacheFile commitDiskCacheFile(DiskCacheFile diskCacheFile) {
DiskCacheFile diskCacheFile2;
ProcessLock processLock;
Throwable th;
InterruptedException e;
if (!this.available || diskCacheFile == null) {
return diskCacheFile;
}
DiskCacheEntity cacheEntity = diskCacheFile.getCacheEntity();
if (!diskCacheFile.getName().endsWith(".tmp")) {
return diskCacheFile;
}
DiskCacheFile diskCacheFile3 = null;
try {
String path = cacheEntity.getPath();
processLock = ProcessLock.tryLock(path, true, 3000);
if (processLock != null) {
try {
if (processLock.isValid()) {
diskCacheFile2 = new DiskCacheFile(path, cacheEntity, processLock);
try {
if (diskCacheFile.renameTo(diskCacheFile2)) {
try {
this.cacheDb.replace(cacheEntity);
} catch (Throwable th2) {
LogUtil.e(th2.getMessage(), th2);
}
trimSize();
IOUtil.closeQuietly(diskCacheFile);
IOUtil.deleteFileOrDir(diskCacheFile);
return diskCacheFile2;
}
throw new IOException("rename:" + diskCacheFile.getAbsolutePath());
} catch (InterruptedException e2) {
} catch (Throwable th3) {
th = th3;
if (diskCacheFile3 == null) {
}
throw th;
}
}
} catch (InterruptedException e3) {
e = e3;
try {
LogUtil.e(e.getMessage(), e);
IOUtil.closeQuietly(diskCacheFile);
IOUtil.deleteFileOrDir(diskCacheFile);
return diskCacheFile;
} catch (Throwable th4) {
th = th4;
diskCacheFile2 = diskCacheFile3;
diskCacheFile3 = diskCacheFile;
if (diskCacheFile3 == null) {
IOUtil.closeQuietly(diskCacheFile2);
IOUtil.closeQuietly(processLock);
IOUtil.deleteFileOrDir(diskCacheFile2);
} else {
IOUtil.closeQuietly(diskCacheFile);
IOUtil.deleteFileOrDir(diskCacheFile);
}
throw th;
}
} catch (Throwable th5) {
th = th5;
diskCacheFile2 = null;
if (diskCacheFile3 == null) {
}
throw th;
}
}
throw new FileLockedException(path);
} catch (InterruptedException e4) {
e = e4;
processLock = null;
LogUtil.e(e.getMessage(), e);
IOUtil.closeQuietly(diskCacheFile);
IOUtil.deleteFileOrDir(diskCacheFile);
return diskCacheFile;
} catch (Throwable th6) {
th = th6;
processLock = null;
diskCacheFile2 = null;
if (diskCacheFile3 == null) {
}
throw th;
}
}
public DiskCacheFile createDiskCacheFile(DiskCacheEntity diskCacheEntity) {
if (!this.available || diskCacheEntity == null) {
return null;
}
diskCacheEntity.setPath(new File(this.cacheDir, MD5.md5(diskCacheEntity.getKey())).getAbsolutePath());
String str = diskCacheEntity.getPath() + ".tmp";
ProcessLock tryLock = ProcessLock.tryLock(str, true);
if (tryLock == null || !tryLock.isValid()) {
throw new FileLockedException(diskCacheEntity.getPath());
}
DiskCacheFile diskCacheFile = new DiskCacheFile(str, diskCacheEntity, tryLock);
if (!diskCacheFile.getParentFile().exists()) {
diskCacheFile.mkdirs();
}
return diskCacheFile;
}
public DiskCacheEntity get(String str) {
final DiskCacheEntity diskCacheEntity;
if (!this.available || TextUtils.isEmpty(str)) {
return null;
}
try {
diskCacheEntity = (DiskCacheEntity) this.cacheDb.selector(DiskCacheEntity.class).where("key", "=", str).findFirst();
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
diskCacheEntity = null;
}
if (diskCacheEntity != null) {
if (diskCacheEntity.getExpires() < System.currentTimeMillis()) {
return null;
}
this.trimExecutor.execute(new Runnable() {
/* class com.duoyou.task.sdk.xutils.cache.LruDiskCache.AnonymousClass1 */
public void run() {
DiskCacheEntity diskCacheEntity = diskCacheEntity;
diskCacheEntity.setHits(diskCacheEntity.getHits() + 1);
diskCacheEntity.setLastAccess(System.currentTimeMillis());
try {
LruDiskCache.this.cacheDb.update(diskCacheEntity, "hits", "lastAccess");
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
}
}
});
}
return diskCacheEntity;
}
public DiskCacheFile getDiskCacheFile(String str) {
DiskCacheEntity diskCacheEntity;
ProcessLock tryLock;
if (!this.available || TextUtils.isEmpty(str) || (diskCacheEntity = get(str)) == null || !new File(diskCacheEntity.getPath()).exists() || (tryLock = ProcessLock.tryLock(diskCacheEntity.getPath(), false, 3000)) == null || !tryLock.isValid()) {
return null;
}
DiskCacheFile diskCacheFile = new DiskCacheFile(diskCacheEntity.getPath(), diskCacheEntity, tryLock);
if (diskCacheFile.exists()) {
return diskCacheFile;
}
try {
this.cacheDb.delete(diskCacheEntity);
return null;
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
return null;
}
}
public void put(DiskCacheEntity diskCacheEntity) {
if (this.available && diskCacheEntity != null && !TextUtils.isEmpty(diskCacheEntity.getTextContent()) && diskCacheEntity.getExpires() >= System.currentTimeMillis()) {
try {
this.cacheDb.replace(diskCacheEntity);
} catch (Throwable th) {
LogUtil.e(th.getMessage(), th);
}
trimSize();
}
}
public LruDiskCache setMaxSize(long j) {
if (j > 0) {
long diskAvailableSize = FileUtil.getDiskAvailableSize();
if (diskAvailableSize > j) {
this.diskCacheSize = j;
} else {
this.diskCacheSize = diskAvailableSize;
}
}
return this;
}
}