package com.firemonkeys.cloudcellapi;

import android.content.SharedPreferences;
import android.os.AsyncTask;
import com.amazon.device.iap.PurchasingListener;
import com.amazon.device.iap.PurchasingService;
import com.amazon.device.iap.model.FulfillmentResult;
import com.amazon.device.iap.model.Product;
import com.amazon.device.iap.model.ProductDataResponse;
import com.amazon.device.iap.model.ProductType;
import com.amazon.device.iap.model.PurchaseResponse;
import com.amazon.device.iap.model.PurchaseUpdatesResponse;
import com.amazon.device.iap.model.Receipt;
import com.amazon.device.iap.model.UserData;
import com.amazon.device.iap.model.UserDataResponse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

/* loaded from: classes2.dex */
public class CC_AmazonStoreObserver_Class implements PurchasingListener {
    private static final String CLASSNAME = "CC_AmazonStoreObserver_Class";
    private static long m_nConstructCallback = 0;
    private static long m_nProductDetailsCallback = 0;
    private static long m_nPurchaseErrorCallback = 0;
    private static long m_nPurchaseSucceedCallback = 0;
    private static long m_nRestoreCallback = 0;
    private static long m_nUserPointer = 0;
    private static final String s_sAppTesterAccount1 = "l3HL7XppEMhrOGDnur9-ulvqomrSg6qyODKmah76lJU=";
    private String currentUser;
    private int m_nNumOutstandingProductRequests = 0;
    Map<String, Product> mRetrievedProducts = null;
    ArrayList<Receipt> mRestoreReceipts = new ArrayList<>();
    String sActivePurchaseProductId = null;

    /* JADX INFO: Access modifiers changed from: private */
    public static native void ConstructCallback(boolean z, boolean z2, long j, long j2);

    /* JADX INFO: Access modifiers changed from: private */
    public static native void ProductDetailsCallback(boolean z, Product[] productArr, long j, long j2);

    private static native void PurchaseErrorCallback(String str, long j, long j2, long j3);

    private static native void PurchaseSucceedCallback(String str, Receipt receipt, long j, long j2);

    private static native void RefreshCallback(boolean z, long j);

    /* JADX INFO: Access modifiers changed from: private */
    public static native void RestoreCallback(boolean z, String str, Receipt[] receiptArr, long j, long j2);

    public String getCurrentUser() {
        return this.currentUser;
    }

    public void setCurrentUser(String str) {
        this.currentUser = str;
    }

    public CC_AmazonStoreObserver_Class(long j, long j2, long j3, long j4, long j5, long j6) {
        m_nConstructCallback = j;
        m_nProductDetailsCallback = j2;
        m_nPurchaseSucceedCallback = j3;
        m_nPurchaseErrorCallback = j4;
        m_nRestoreCallback = j5;
        m_nUserPointer = j6;
    }

    @Override // com.amazon.device.iap.PurchasingListener
    public void onUserDataResponse(UserDataResponse userDataResponse) {
        Logging.CC_TRACE(CLASSNAME, "onUserDataResponse recieved: Response " + userDataResponse);
        Logging.CC_TRACE(CLASSNAME, "RequestId:" + userDataResponse.getRequestId());
        Logging.CC_TRACE(CLASSNAME, "IdRequestStatus:" + userDataResponse.getRequestStatus());
        new GetUserIdAsyncTask().execute(userDataResponse);
    }

    public class GetUserIdAsyncTask extends AsyncTask<UserDataResponse, Void, Boolean> {
        private GetUserIdAsyncTask() {
        }

        @Override // android.os.AsyncTask
        public Boolean doInBackground(UserDataResponse... userDataResponseArr) {
            UserDataResponse userDataResponse = userDataResponseArr[0];
            if (userDataResponse.getRequestStatus() == UserDataResponse.RequestStatus.SUCCESSFUL) {
                Logging.CC_TRACE(CC_AmazonStoreObserver_Class.CLASSNAME, "doInBackground SUCCESSFUL");
                CC_AmazonStoreObserver_Class.this.setCurrentUser(userDataResponse.getUserData().getUserId());
                return Boolean.TRUE;
            }
            Logging.CC_TRACE(CC_AmazonStoreObserver_Class.CLASSNAME, "doInBackground: Unable to get user ID.");
            return Boolean.FALSE;
        }

        @Override // android.os.AsyncTask
        public void onPostExecute(Boolean bool) {
            super.onPostExecute((GetUserIdAsyncTask) bool);
            CC_AmazonStoreObserver_Class.ConstructCallback(bool.booleanValue(), bool.booleanValue(), CC_AmazonStoreObserver_Class.m_nConstructCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
        }
    }

    public void getProductDetails(String[] strArr) {
        Logging.CC_TRACE(CLASSNAME, "getProductDetails Begin");
        if (this.mRetrievedProducts != null) {
            Logging.CC_ERROR(CLASSNAME, "getProductDetails called when a previous request has not completed");
            return;
        }
        int length = strArr.length;
        if (length <= 0) {
            Logging.CC_WARNING(CLASSNAME, "getProductDetails called with no product Ids");
            return;
        }
        this.mRetrievedProducts = new HashMap();
        int i = 0;
        this.m_nNumOutstandingProductRequests = 0;
        ArrayList arrayList = new ArrayList();
        while (i < length) {
            HashSet hashSet = new HashSet();
            while (hashSet.size() < 100 && i < length) {
                hashSet.add(strArr[i]);
                i++;
            }
            Logging.CC_TRACE(CLASSNAME, "adding request for " + hashSet.size() + " products up to item " + i);
            arrayList.add(hashSet);
        }
        this.m_nNumOutstandingProductRequests = arrayList.size();
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            PurchasingService.getProductData((HashSet) it.next());
        }
    }

    @Override // com.amazon.device.iap.PurchasingListener
    public void onProductDataResponse(ProductDataResponse productDataResponse) {
        Logging.CC_TRACE(CLASSNAME, "onProductDataResponse recieved");
        Logging.CC_TRACE(CLASSNAME, "ProductDataRequestStatus" + productDataResponse.getRequestStatus());
        Logging.CC_TRACE(CLASSNAME, "ProductDataRequestId" + productDataResponse.getRequestId());
        new ProductDataAsyncTask().execute(productDataResponse);
    }

    public class ProductDataAsyncTask extends AsyncTask<ProductDataResponse, Void, Void> {
        private ProductDataAsyncTask() {
        }

        @Override // android.os.AsyncTask
        public Void doInBackground(ProductDataResponse... productDataResponseArr) {
            ProductDataResponse productDataResponse = productDataResponseArr[0];
            CC_AmazonStoreObserver_Class cC_AmazonStoreObserver_Class = CC_AmazonStoreObserver_Class.this;
            if (cC_AmazonStoreObserver_Class.mRetrievedProducts != null) {
                cC_AmazonStoreObserver_Class.m_nNumOutstandingProductRequests--;
                int i = AnonymousClass1.$SwitchMap$com$amazon$device$iap$model$ProductDataResponse$RequestStatus[productDataResponse.getRequestStatus().ordinal()];
                if (i == 1 || i == 2) {
                    Map<String, Product> productData = productDataResponse.getProductData();
                    for (String str : productData.keySet()) {
                        Product product = productData.get(str);
                        Logging.CC_INFO(CC_AmazonStoreObserver_Class.CLASSNAME, String.format("Product: %s\n Type: %s\n SKU: %s\n Price: %s\n Description: %s\n", product.getTitle(), product.getProductType(), product.getSku(), product.getPrice(), product.getDescription()));
                        CC_AmazonStoreObserver_Class.this.mRetrievedProducts.put(str, product);
                    }
                    if (CC_AmazonStoreObserver_Class.this.m_nNumOutstandingProductRequests <= 0) {
                        Logging.CC_TRACE(CC_AmazonStoreObserver_Class.CLASSNAME, "retrieved products complete with " + CC_AmazonStoreObserver_Class.this.mRetrievedProducts.size() + " products");
                        Product[] productArr = (Product[]) CC_AmazonStoreObserver_Class.this.mRetrievedProducts.values().toArray(new Product[CC_AmazonStoreObserver_Class.this.mRetrievedProducts.size()]);
                        CC_AmazonStoreObserver_Class cC_AmazonStoreObserver_Class2 = CC_AmazonStoreObserver_Class.this;
                        cC_AmazonStoreObserver_Class2.mRetrievedProducts = null;
                        cC_AmazonStoreObserver_Class2.m_nNumOutstandingProductRequests = 0;
                        CC_AmazonStoreObserver_Class.ProductDetailsCallback(true, productArr, CC_AmazonStoreObserver_Class.m_nProductDetailsCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
                    }
                } else if (i == 3) {
                    CC_AmazonStoreObserver_Class cC_AmazonStoreObserver_Class3 = CC_AmazonStoreObserver_Class.this;
                    cC_AmazonStoreObserver_Class3.mRetrievedProducts = null;
                    cC_AmazonStoreObserver_Class3.m_nNumOutstandingProductRequests = 0;
                    CC_AmazonStoreObserver_Class.ProductDetailsCallback(false, null, CC_AmazonStoreObserver_Class.m_nProductDetailsCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
                }
            }
            return null;
        }
    }

    public void Purchase(String str) {
        Logging.CC_INFO(CLASSNAME, "Purchasing " + str);
        this.sActivePurchaseProductId = str;
        PurchasingService.purchase(str);
    }

    @Override // com.amazon.device.iap.PurchasingListener
    public void onPurchaseResponse(PurchaseResponse purchaseResponse) {
        Logging.CC_TRACE(CLASSNAME, "onPurchaseResponse recieved");
        Logging.CC_TRACE(CLASSNAME, "PurchaseRequestStatus: " + purchaseResponse.getRequestStatus());
        Receipt receipt = purchaseResponse.getReceipt();
        printReceipt(receipt);
        int i = AnonymousClass1.$SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus[purchaseResponse.getRequestStatus().ordinal()];
        if (i == 1) {
            PurchaseSucceedCallback(purchaseResponse.getUserData().getUserId(), receipt, m_nPurchaseSucceedCallback, m_nUserPointer);
        } else if (i == 2 || i == 3 || i == 4 || i == 5) {
            PurchaseErrorCallback(this.sActivePurchaseProductId, purchaseResponse.getRequestStatus().ordinal(), m_nPurchaseErrorCallback, m_nUserPointer);
        }
        this.sActivePurchaseProductId = null;
    }

    public void CompleteTransaction(String str, Boolean bool) {
        Logging.CC_TRACE(CLASSNAME, "CompleteTransaction");
        Logging.CC_TRACE(CLASSNAME, "fulfilled: " + bool);
        if (bool.booleanValue()) {
            PurchasingService.notifyFulfillment(str, FulfillmentResult.FULFILLED);
        } else {
            PurchasingService.notifyFulfillment(str, FulfillmentResult.UNAVAILABLE);
        }
    }

    public void RefreshStorePurchases() {
        Logging.CC_TRACE(CLASSNAME, "RefreshStorePurchases");
        PurchasingService.getPurchaseUpdates(false);
    }

    public void RestorePurchase() {
        Logging.CC_TRACE(CLASSNAME, "RestorePurchase");
        this.mRestoreReceipts.clear();
        PurchasingService.getPurchaseUpdates(true);
    }

    @Override // com.amazon.device.iap.PurchasingListener
    public void onPurchaseUpdatesResponse(PurchaseUpdatesResponse purchaseUpdatesResponse) {
        Logging.CC_TRACE(CLASSNAME, "onPurchaseUpdatesRecived received: Response -" + purchaseUpdatesResponse);
        Logging.CC_TRACE(CLASSNAME, "RequestStatus:" + purchaseUpdatesResponse.getRequestStatus());
        Logging.CC_TRACE(CLASSNAME, "RequestID:" + purchaseUpdatesResponse.getRequestId());
        new PurchaseUpdatesAsyncTask().execute(purchaseUpdatesResponse);
    }

    public class PurchaseUpdatesAsyncTask extends AsyncTask<PurchaseUpdatesResponse, Void, Boolean> {
        private PurchaseUpdatesAsyncTask() {
        }

        @Override // android.os.AsyncTask
        public Boolean doInBackground(PurchaseUpdatesResponse... purchaseUpdatesResponseArr) {
            int i = 0;
            PurchaseUpdatesResponse purchaseUpdatesResponse = purchaseUpdatesResponseArr[0];
            String currentUser = CC_AmazonStoreObserver_Class.this.getCurrentUser();
            UserData userData = purchaseUpdatesResponse.getUserData();
            String userId = userData != null ? userData.getUserId() : null;
            if (userId == null || (!userId.equals(currentUser) && (currentUser == null || (!currentUser.equals(CC_AmazonStoreObserver_Class.s_sAppTesterAccount1) && !userId.equals(""))))) {
                if (userId == null) {
                    userId = "";
                }
                Logging.CC_WARNING(CC_AmazonStoreObserver_Class.CLASSNAME, "Reject PurchaseUpdatesAsyncTask for user " + userId + " Excepted user " + currentUser);
                CC_AmazonStoreObserver_Class.RestoreCallback(false, userId, null, CC_AmazonStoreObserver_Class.m_nRestoreCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
                return Boolean.FALSE;
            }
            int i2 = AnonymousClass1.$SwitchMap$com$amazon$device$iap$model$PurchaseUpdatesResponse$RequestStatus[purchaseUpdatesResponse.getRequestStatus().ordinal()];
            if (i2 != 1) {
                if (i2 != 2) {
                    return Boolean.FALSE;
                }
                CC_AmazonStoreObserver_Class.RestoreCallback(false, purchaseUpdatesResponse.getUserData().getUserId(), null, CC_AmazonStoreObserver_Class.m_nRestoreCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
                return Boolean.FALSE;
            }
            for (Receipt receipt : purchaseUpdatesResponse.getReceipts()) {
                if (AnonymousClass1.$SwitchMap$com$amazon$device$iap$model$ProductType[receipt.getProductType().ordinal()] == 1) {
                    Logging.CC_TRACE(CC_AmazonStoreObserver_Class.CLASSNAME, "PurchaseUpdatesAsyncTask: consumable product for Restore");
                }
                CC_AmazonStoreObserver_Class.this.mRestoreReceipts.add(receipt);
                CC_AmazonStoreObserver_Class.this.printReceipt(receipt);
            }
            if (purchaseUpdatesResponse.hasMore()) {
                Logging.CC_TRACE(CC_AmazonStoreObserver_Class.CLASSNAME, "Initiating Another Purchase Updates");
                PurchasingService.getPurchaseUpdates(false);
            } else {
                Receipt[] receiptArr = new Receipt[CC_AmazonStoreObserver_Class.this.mRestoreReceipts.size()];
                Iterator<Receipt> it = CC_AmazonStoreObserver_Class.this.mRestoreReceipts.iterator();
                while (it.hasNext()) {
                    receiptArr[i] = it.next();
                    i++;
                }
                CC_AmazonStoreObserver_Class.this.mRestoreReceipts.clear();
                CC_AmazonStoreObserver_Class.RestoreCallback(true, purchaseUpdatesResponse.getUserData().getUserId(), receiptArr, CC_AmazonStoreObserver_Class.m_nRestoreCallback, CC_AmazonStoreObserver_Class.m_nUserPointer);
            }
            return Boolean.TRUE;
        }

        @Override // android.os.AsyncTask
        public void onPostExecute(Boolean bool) {
            super.onPostExecute((PurchaseUpdatesAsyncTask) bool);
        }
    }

    /* renamed from: com.firemonkeys.cloudcellapi.CC_AmazonStoreObserver_Class$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$com$amazon$device$iap$model$ProductDataResponse$RequestStatus;
        static final /* synthetic */ int[] $SwitchMap$com$amazon$device$iap$model$ProductType;
        static final /* synthetic */ int[] $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus;
        static final /* synthetic */ int[] $SwitchMap$com$amazon$device$iap$model$PurchaseUpdatesResponse$RequestStatus;

        static {
            int[] iArr = new int[PurchaseUpdatesResponse.RequestStatus.values().length];
            $SwitchMap$com$amazon$device$iap$model$PurchaseUpdatesResponse$RequestStatus = iArr;
            try {
                iArr[PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$PurchaseUpdatesResponse$RequestStatus[PurchaseUpdatesResponse.RequestStatus.FAILED.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            int[] iArr2 = new int[ProductType.values().length];
            $SwitchMap$com$amazon$device$iap$model$ProductType = iArr2;
            try {
                iArr2[ProductType.CONSUMABLE.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$ProductType[ProductType.ENTITLED.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$ProductType[ProductType.SUBSCRIPTION.ordinal()] = 3;
            } catch (NoSuchFieldError unused5) {
            }
            int[] iArr3 = new int[PurchaseResponse.RequestStatus.values().length];
            $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus = iArr3;
            try {
                iArr3[PurchaseResponse.RequestStatus.SUCCESSFUL.ordinal()] = 1;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus[PurchaseResponse.RequestStatus.ALREADY_PURCHASED.ordinal()] = 2;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus[PurchaseResponse.RequestStatus.FAILED.ordinal()] = 3;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus[PurchaseResponse.RequestStatus.INVALID_SKU.ordinal()] = 4;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$PurchaseResponse$RequestStatus[PurchaseResponse.RequestStatus.NOT_SUPPORTED.ordinal()] = 5;
            } catch (NoSuchFieldError unused10) {
            }
            int[] iArr4 = new int[ProductDataResponse.RequestStatus.values().length];
            $SwitchMap$com$amazon$device$iap$model$ProductDataResponse$RequestStatus = iArr4;
            try {
                iArr4[ProductDataResponse.RequestStatus.NOT_SUPPORTED.ordinal()] = 1;
            } catch (NoSuchFieldError unused11) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$ProductDataResponse$RequestStatus[ProductDataResponse.RequestStatus.SUCCESSFUL.ordinal()] = 2;
            } catch (NoSuchFieldError unused12) {
            }
            try {
                $SwitchMap$com$amazon$device$iap$model$ProductDataResponse$RequestStatus[ProductDataResponse.RequestStatus.FAILED.ordinal()] = 3;
            } catch (NoSuchFieldError unused13) {
            }
        }
    }

    private SharedPreferences getSharedPreferencesForCurrentUser() {
        return CC_Component.GetActivity().getSharedPreferences(getCurrentUser(), 0);
    }

    private SharedPreferences.Editor getSharedPreferencesEditor() {
        return getSharedPreferencesForCurrentUser().edit();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void printReceipt(Receipt receipt) {
        if (receipt == null) {
            Logging.CC_INFO(CLASSNAME, "Receipt: null");
        } else {
            Logging.CC_INFO(CLASSNAME, String.format("Receipt: ProductType: %s Sku: %s SubscriptionPeriod: %s - %s", receipt.getProductType(), receipt.getSku(), receipt.getPurchaseDate(), receipt.getCancelDate()));
        }
    }
}