package I2;

import C3.ServiceConnectionC0128d;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import com.google.android.gms.internal.play_billing.zzau;
import com.google.android.gms.internal.play_billing.zzc;
import com.google.android.gms.internal.play_billing.zzcu;
import com.google.android.gms.internal.play_billing.zzcz;
import com.google.android.gms.internal.play_billing.zzhx;
import com.google.android.gms.internal.play_billing.zzib;
import com.google.android.gms.internal.play_billing.zzie;
import com.google.android.gms.internal.play_billing.zzil;
import com.google.android.gms.internal.play_billing.zzis;
import com.google.android.gms.internal.play_billing.zzu;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/* JADX INFO: loaded from: classes.dex */
public final class S extends C0320d {

    /* JADX INFO: renamed from: H, reason: collision with root package name */
    public final Context f2530H;

    /* JADX INFO: renamed from: I, reason: collision with root package name */
    public volatile int f2531I;

    /* JADX INFO: renamed from: J, reason: collision with root package name */
    public volatile zzau f2532J;

    /* JADX INFO: renamed from: K, reason: collision with root package name */
    public volatile ServiceConnectionC0128d f2533K;

    /* JADX INFO: renamed from: L, reason: collision with root package name */
    public volatile ScheduledExecutorService f2534L;

    public S(C0331o c0331o, Context context, C0318b c0318b) {
        super(c0331o, context, c0318b);
        this.f2531I = 0;
        this.f2530H = context;
    }

    public final zzcz O(int i6) {
        if (V()) {
            return zzu.zza(new C1.k(this, i6));
        }
        zzc.zzn("BillingClientTesting", "Billing Override Service is not ready.");
        P(28, V.a(-1, "Billing Override Service connection is disconnected."), zzie.BILLING_OVERRIDE_SERVICE_CONNECTION_NOT_READY);
        return zzcu.zza(0);
    }

    public final void P(int i6, C0328l c0328l, zzie zzieVar) {
        int i7 = T.f2535a;
        zzhx zzhxVarB = T.b(zzieVar, i6, c0328l, null, zzil.BROADCAST_ACTION_UNSPECIFIED);
        Objects.requireNonNull(zzhxVarB, "ApiFailure should not be null");
        this.f2598h.y(zzhxVarB);
    }

    public final void Q(int i6) {
        int i7 = T.f2535a;
        zzib zzibVarC = T.c(i6, zzil.BROADCAST_ACTION_UNSPECIFIED);
        Objects.requireNonNull(zzibVarC, "ApiSuccess should not be null");
        T.p pVar = this.f2598h;
        pVar.getClass();
        try {
            pVar.F(zzibVarC, (zzis) pVar.f6345b);
        } catch (Throwable th) {
            zzc.zzo("BillingLogger", "Unable to log.", th);
        }
    }

    public final void R(int i6, E1.a aVar, Runnable runnable) {
        ScheduledExecutorService scheduledExecutorService;
        zzcz zzczVarO = O(i6);
        TimeUnit timeUnit = TimeUnit.MILLISECONDS;
        synchronized (this) {
            try {
                if (this.f2534L == null) {
                    this.f2534L = Executors.newSingleThreadScheduledExecutor();
                }
                scheduledExecutorService = this.f2534L;
            } catch (Throwable th) {
                throw th;
            }
        }
        zzcu.zzc(zzcu.zzb(zzczVarO, 28500L, timeUnit, scheduledExecutorService), new O(this, i6, aVar, runnable), i());
    }

    public final synchronized boolean V() {
        if (this.f2531I == 2 && this.f2532J != null) {
            if (this.f2533K != null) {
                return true;
            }
        }
        return false;
    }

    @Override // I2.C0320d, I2.AbstractC0319c
    public final void a(C0317a c0317a, com.revenuecat.purchases.google.usecase.a aVar) {
        R(3, new C1.h(aVar, 3), new C1.o((C0320d) this, (Object) c0317a, (Object) aVar, 4));
    }

    @Override // I2.C0320d, I2.AbstractC0319c
    public final void b(final C0317a c0317a, final com.revenuecat.purchases.google.usecase.a aVar) {
        R(4, new E1.a() { // from class: I2.P
            @Override // E1.a
            public final void accept(Object obj) {
                String str = c0317a.f2580b;
                aVar.d((C0328l) obj, str);
            }
        }, new C1.o((C0320d) this, (Object) c0317a, (Object) aVar, 3));
    }

    @Override // I2.C0320d, I2.AbstractC0319c
    public final void c() {
        synchronized (this) {
            Q(27);
            try {
                try {
                    if (this.f2533K != null && this.f2532J != null) {
                        zzc.zzm("BillingClientTesting", "Unbinding from Billing Override Service.");
                        this.f2530H.unbindService(this.f2533K);
                        this.f2533K = new ServiceConnectionC0128d(this);
                    }
                    this.f2532J = null;
                    if (this.f2534L != null) {
                        this.f2534L.shutdownNow();
                        this.f2534L = null;
                    }
                } catch (RuntimeException e6) {
                    zzc.zzo("BillingClientTesting", "There was an exception while ending Billing Override Service connection!", e6);
                }
                this.f2531I = 3;
            } catch (Throwable th) {
                this.f2531I = 3;
                throw th;
            }
        }
        super.c();
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // I2.C0320d, I2.AbstractC0319c
    public final C0328l e(Activity activity, C0326j c0326j) {
        int iIntValue = 0;
        try {
            iIntValue = ((Integer) O(2).get(28500L, TimeUnit.MILLISECONDS)).intValue();
        } catch (TimeoutException e6) {
            P(28, V.f2541E, zzie.BILLING_OVERRIDE_SERVICE_CALL_TIMEOUT);
            zzc.zzo("BillingClientTesting", "Asynchronous call to Billing Override Service timed out.", e6);
        } catch (Exception e7) {
            if (e7 instanceof InterruptedException) {
                Thread.currentThread().interrupt();
            }
            P(28, V.f2541E, zzie.BILLING_OVERRIDE_SERVICE_CALL_EXCEPTION);
            zzc.zzo("BillingClientTesting", "An error occurred while retrieving billing override.", e7);
        }
        if (iIntValue > 0) {
            C0328l c0328lA = V.a(iIntValue, "Billing override value was set by a license tester.");
            P(2, c0328lA, zzie.LICENSE_TESTER_BILLING_OVERRIDE);
            N(c0328lA);
            return c0328lA;
        }
        try {
            return super.e(activity, c0326j);
        } catch (Exception e8) {
            zzie zzieVar = zzie.BILLING_OVERRIDE_SERVICE_FALLBACK_ERROR;
            C0328l c0328l = V.f2549h;
            P(2, c0328l, zzieVar);
            zzc.zzo("BillingClientTesting", "An internal error occurred.", e8);
            return c0328l;
        }
    }

    @Override // I2.C0320d, I2.AbstractC0319c
    public final void f(C0341z c0341z, com.revenuecat.purchases.google.usecase.c cVar) {
        R(7, new C1.h(cVar, 2), new C1.o((C0320d) this, (Object) c0341z, (Object) cVar, 2));
    }

    @Override // I2.C0320d, I2.AbstractC0319c
    public final void h(InterfaceC0321e interfaceC0321e) {
        synchronized (this) {
            if (V()) {
                zzc.zzm("BillingClientTesting", "Billing Override Service connection is valid. No need to re-initialize.");
                Q(26);
            } else if (this.f2531I == 1) {
                zzc.zzn("BillingClientTesting", "Client is already in the process of connecting to Billing Override Service.");
            } else if (this.f2531I == 3) {
                zzc.zzn("BillingClientTesting", "Billing Override Service Client was already closed and can't be reused. Please create another instance.");
                P(26, V.a(-1, "Billing Override Service connection is disconnected."), zzie.BILLING_CLIENT_CLOSED);
            } else {
                this.f2531I = 1;
                zzc.zzm("BillingClientTesting", "Starting Billing Override Service setup.");
                this.f2533K = new ServiceConnectionC0128d(this);
                Intent intent = new Intent("com.google.android.apps.play.billingtestcompanion.BillingOverrideService.BIND");
                intent.setPackage("com.google.android.apps.play.billingtestcompanion");
                Context context = this.f2530H;
                List<ResolveInfo> listQueryIntentServices = context.getPackageManager().queryIntentServices(intent, 0);
                zzie zzieVar = zzie.REASON_UNSPECIFIED;
                if (listQueryIntentServices == null || listQueryIntentServices.isEmpty()) {
                    zzieVar = zzie.INTENT_SERVICE_NOT_FOUND;
                } else {
                    ServiceInfo serviceInfo = listQueryIntentServices.get(0).serviceInfo;
                    if (serviceInfo != null) {
                        String str = serviceInfo.packageName;
                        String str2 = serviceInfo.name;
                        if (!Objects.equals(str, "com.google.android.apps.play.billingtestcompanion") || str2 == null) {
                            zzieVar = zzie.BILLING_SERVICE_BLOCKED;
                            zzc.zzn("BillingClientTesting", "The device doesn't have valid Play Billing Lab.");
                        } else {
                            ComponentName componentName = new ComponentName(str, str2);
                            Intent intent2 = new Intent(intent);
                            intent2.setComponent(componentName);
                            if (context.bindService(intent2, this.f2533K, 1)) {
                                zzc.zzm("BillingClientTesting", "Billing Override Service was bonded successfully.");
                            } else {
                                zzieVar = zzie.BILLING_SERVICE_BLOCKED;
                                zzc.zzn("BillingClientTesting", "Connection to Billing Override Service is blocked.");
                            }
                        }
                    }
                }
                this.f2531I = 0;
                zzc.zzm("BillingClientTesting", "Billing Override Service unavailable on device.");
                P(26, V.a(2, "Billing Override Service unavailable on device."), zzieVar);
            }
        }
        s(interfaceC0321e, 0);
    }

    public S(C0331o c0331o, Context context, InterfaceC0339x interfaceC0339x, C0318b c0318b) {
        super(c0331o, context, interfaceC0339x, c0318b);
        this.f2531I = 0;
        this.f2530H = context;
    }
}