package com.parse;

import com.parse.ParseQuery;
import java.util.List;
import java.util.concurrent.Callable;
import org.json.JSONException;
import org.json.JSONObject;
import p137.C2742;
import p137.InterfaceC2741;

/* JADX INFO: loaded from: classes.dex */
public class CacheQueryController extends AbstractQueryController {
    public final NetworkQueryController networkController;

    /* JADX INFO: Add missing generic type declarations: [T] */
    /* JADX INFO: renamed from: com.parse.CacheQueryController$1, reason: invalid class name */
    public class AnonymousClass1<T> implements CommandDelegate<List<T>> {
        public final /* synthetic */ C2742 val$cancellationToken;
        public final /* synthetic */ String val$sessionToken;
        public final /* synthetic */ ParseQuery.State val$state;

        public AnonymousClass1(ParseQuery.State state, String str, C2742 c2742) {
            this.val$state = state;
            this.val$sessionToken = str;
            this.val$cancellationToken = c2742;
        }

        public C2742<List<T>> runFromCacheAsync() {
            final CacheQueryController cacheQueryController = CacheQueryController.this;
            final ParseQuery.State state = this.val$state;
            String str = this.val$sessionToken;
            if (cacheQueryController == null) {
                throw null;
            }
            final String cacheKey = ParseRESTQueryCommand.findCommand(state, str).getCacheKey();
            return C2742.m4802(new Callable<List<T>>() { // from class: com.parse.CacheQueryController.3
                @Override // java.util.concurrent.Callable
                public Object call() throws ParseException {
                    String str2 = cacheKey;
                    String strLoadFromKeyValueCache = ParseKeyValueCache.loadFromKeyValueCache(str2, state.maxCacheAge);
                    JSONObject jSONObject = null;
                    if (strLoadFromKeyValueCache != null) {
                        try {
                            jSONObject = new JSONObject(strLoadFromKeyValueCache);
                        } catch (JSONException e) {
                            PLog.log(6, "ParseKeyValueCache", "corrupted cache for " + str2, e);
                            ParseKeyValueCache.clearFromKeyValueCache(str2);
                        }
                    }
                    if (jSONObject == null) {
                        throw new ParseException(120, "results not cached");
                    }
                    try {
                        return CacheQueryController.this.networkController.convertFindResponse(state, jSONObject);
                    } catch (JSONException unused) {
                        throw new ParseException(120, "the cache contains corrupted json");
                    }
                }
            }, C2742.f8454);
        }

        public C2742<List<T>> runOnNetworkAsync() {
            return CacheQueryController.this.networkController.findAsync(this.val$state, this.val$sessionToken, this.val$cancellationToken);
        }
    }

    public interface CommandDelegate<T> {
    }

    public CacheQueryController(NetworkQueryController networkQueryController) {
        this.networkController = networkQueryController;
    }

    @Override // com.parse.ParseQueryController
    public <T extends ParseObject> C2742<List<T>> findAsync(ParseQuery.State<T> state, ParseUser parseUser, C2742<Void> c2742) {
        final AnonymousClass1 anonymousClass1 = new AnonymousClass1(state, parseUser != null ? parseUser.getSessionToken() : null, c2742);
        ParseQuery.CachePolicy cachePolicy = state.cachePolicy;
        int iOrdinal = cachePolicy.ordinal();
        if (iOrdinal != 0) {
            if (iOrdinal == 1) {
                return anonymousClass1.runFromCacheAsync();
            }
            if (iOrdinal != 2) {
                if (iOrdinal == 3) {
                    return anonymousClass1.runFromCacheAsync().m4815(new InterfaceC2741<TResult, C2742<TResult>>(this) { // from class: com.parse.CacheQueryController.5
                        @Override // p137.InterfaceC2741
                        public Object then(C2742 c27422) {
                            return c27422.m4806() instanceof ParseException ? ((AnonymousClass1) anonymousClass1).runOnNetworkAsync() : c27422;
                        }
                    }, C2742.f8455, null);
                }
                if (iOrdinal == 4) {
                    return anonymousClass1.runOnNetworkAsync().m4815(new InterfaceC2741<TResult, C2742<TResult>>(this) { // from class: com.parse.CacheQueryController.6
                        @Override // p137.InterfaceC2741
                        public Object then(C2742 c27422) {
                            Exception excM4806 = c27422.m4806();
                            return ((excM4806 instanceof ParseException) && ((ParseException) excM4806).code == 100) ? ((AnonymousClass1) anonymousClass1).runFromCacheAsync() : c27422;
                        }
                    }, C2742.f8455, null);
                }
                if (iOrdinal == 5) {
                    throw new RuntimeException("You cannot use the cache policy CACHE_THEN_NETWORK with find()");
                }
                throw new RuntimeException("Unknown cache policy: " + cachePolicy);
            }
        }
        return anonymousClass1.runOnNetworkAsync();
    }
}