Hopscotch v9.7.2 - PaymentStateActivity.java 源代码

package in.hopscotch.android.payment;

import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.MenuItem;
import android.view.ViewGroup;
import androidx.activity.c0;
import androidx.appcompat.app.i;
import androidx.databinding.p;
import androidx.fragment.app.n;
import androidx.lifecycle.LifecycleOwnerKt;
import androidx.lifecycle.Observer;
import androidx.work.d0;
import androidx.work.f0;
import androidx.work.g;
import androidx.work.impl.n0;
import androidx.work.t;
import com.google.android.gms.internal.icing.v1;
import com.segment.analytics.Properties;
import in.hopscotch.android.api.factory.CheckoutApiFactory;
import in.hopscotch.android.api.factory.CustomerInfoApiFactory;
import in.hopscotch.android.api.model.AllAddressItem;
import in.hopscotch.android.api.model.CreditPromotionData;
import in.hopscotch.android.api.model.Header;
import in.hopscotch.android.api.model.HeaderItem;
import in.hopscotch.android.api.model.MessageBar;
import in.hopscotch.android.api.model.OrderConfirmationDetails;
import in.hopscotch.android.api.model.OrderDetails;
import in.hopscotch.android.api.model.OrderSummary;
import in.hopscotch.android.api.model.PaymentDetails;
import in.hopscotch.android.api.model.PromoItem;
import in.hopscotch.android.api.model.PromotionData;
import in.hopscotch.android.api.model.ReviewCartItem;
import in.hopscotch.android.api.model.ShoppingBagResponse;
import in.hopscotch.android.api.model.TotalOrderAmount;
import in.hopscotch.android.api.response.ActionResponse;
import in.hopscotch.android.api.response.Error;
import in.hopscotch.android.api.response.InitJusPayResponse;
import in.hopscotch.android.api.response.OrderConfirmationResponse;
import in.hopscotch.android.api.response.PaymentState;
import in.hopscotch.android.application.HsApplication;
import in.hopscotch.android.databinding.q1;
import in.hopscotch.android.payment.b;
import in.hopscotch.android.ui.orders.OrdersMainActivity;
import in.hopscotch.android.util.a1;
import in.hopscotch.android.util.j1;
import in.hopscotch.android.util.l0;
import in.juspay.hyperinteg.HyperServiceHolder;
import in.juspay.hypersdk.core.PaymentConstants;
import in.juspay.services.HyperServices;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import kotlin.Metadata;
import kotlin.Unit;
import kotlin.collections.s0;
import kotlin.coroutines.jvm.internal.j;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.functions.Function2;
import kotlin.jvm.internal.FunctionAdapter;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Lambda;
import kotlin.jvm.internal.SourceDebugExtension;
import kotlin.l;
import kotlin.m;
import kotlin.r;
import kotlinx.coroutines.BuildersKt;
import kotlinx.coroutines.BuildersKt__Builders_commonKt;
import kotlinx.coroutines.CoroutineScope;
import kotlinx.coroutines.Dispatchers;
import org.jetbrains.annotations.NotNull;
import org.json.JSONObject;

@Metadata
@SourceDebugExtension({"SMAP\nPaymentStateActivity.kt\nKotlin\n*S Kotlin\n*F\n+ 1 PaymentStateActivity.kt\nin/hopscotch/android/payment/PaymentStateActivity\n+ 2 OneTimeWorkRequest.kt\nandroidx/work/OneTimeWorkRequestKt\n*L\n1#1,660:1\n100#2:661\n*S KotlinDebug\n*F\n+ 1 PaymentStateActivity.kt\nin/hopscotch/android/payment/PaymentStateActivity\n*L\n194#1:661\n*E\n"})
public final class PaymentStateActivity extends i implements b.a {
    public static final int j = 0;
    private boolean exitedFromJuspay;
    private HyperServiceHolder hyperServicesHolder;
    public q1 i;
    private InitJusPayResponse jusPayResponse;
    private long orderId;
    private f0 payStatusWork;
    private in.hopscotch.android.payment.b paymentFragment;

    @NotNull
    private final l workManager$delegate = m.b(new e());

    @NotNull
    private final b onBackPressedCallback = new b();

    public class a {
        public static final int[] a;

        static {
            int[] iArr = new int[PaymentState.values().length];
            try {
                iArr[PaymentState.SUCCESS.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[PaymentState.FAILURE.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                iArr[PaymentState.PENDING.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            a = iArr;
        }
    }

    public static final class b extends c0 {
        public b() {
            super(true);
        }

        public final void d() {
            n nVar = PaymentStateActivity.this;
            HyperServiceHolder hyperServiceHolder = ((PaymentStateActivity) nVar).hyperServicesHolder;
            if ((hyperServiceHolder == null || !hyperServiceHolder.onBackPressed()) && ((PaymentStateActivity) nVar).exitedFromJuspay && !nVar.isFinishing()) {
                in.hopscotch.android.payment.b bVar = new in.hopscotch.android.payment.b();
                bVar.show(nVar.getSupportFragmentManager(), in.hopscotch.android.payment.b.class.getName());
                ((PaymentStateActivity) nVar).paymentFragment = bVar;
            }
        }
    }

    @kotlin.coroutines.jvm.internal.e(c = "in.hopscotch.android.payment.PaymentStateActivity$onCreate$2", f = "PaymentStateActivity.kt", l = {89, 92}, m = "invokeSuspend")
    public static final class c extends j implements Function2<CoroutineScope, kotlin.coroutines.d<? super Unit>, Object> {
        public int a;

        public c(kotlin.coroutines.d<? super c> dVar) {
            super(2, dVar);
        }

        @Override
        @NotNull
        public final kotlin.coroutines.d<Unit> create(Object obj, @NotNull kotlin.coroutines.d<?> dVar) {
            return PaymentStateActivity.this.new c(dVar);
        }

        @Override
        public final Object invoke(CoroutineScope coroutineScope, kotlin.coroutines.d<? super Unit> dVar) {
            return ((c) create(coroutineScope, dVar)).invokeSuspend(Unit.a);
        }

        @Override
        public final Object invokeSuspend(@NotNull Object obj) {
            Object obj2 = kotlin.coroutines.intrinsics.a.COROUTINE_SUSPENDED;
            int i = this.a;
            if (i == 0) {
                r.b(obj);
                PaymentStateActivity paymentStateActivity = PaymentStateActivity.this;
                HyperServiceHolder hyperServiceHolder = paymentStateActivity.hyperServicesHolder;
                if (hyperServiceHolder == null || !hyperServiceHolder.isInitialised()) {
                    HyperServiceHolder hyperServiceHolder2 = paymentStateActivity.hyperServicesHolder;
                    if (hyperServiceHolder2 != null) {
                        l0.a.getClass();
                        hyperServiceHolder2.initiate(l0.a());
                    }
                    this.a = 2;
                    Object withContext = BuildersKt.withContext(Dispatchers.getIO(), new h(paymentStateActivity, null), this);
                    if (withContext != obj2) {
                        withContext = Unit.a;
                    }
                    if (withContext == obj2) {
                        return obj2;
                    }
                } else {
                    this.a = 1;
                    Object withContext2 = BuildersKt.withContext(Dispatchers.getIO(), new h(paymentStateActivity, null), this);
                    if (withContext2 != obj2) {
                        withContext2 = Unit.a;
                    }
                    if (withContext2 == obj2) {
                        return obj2;
                    }
                }
            } else {
                if (i != 1 && i != 2) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                r.b(obj);
            }
            return Unit.a;
        }
    }

    public static final class d implements Observer, FunctionAdapter {
        private final Function1 function;

        public d(Function1 function) {
            Intrinsics.checkNotNullParameter(function, "function");
            this.function = function;
        }

        public final boolean equals(Object obj) {
            if ((obj instanceof Observer) && (obj instanceof FunctionAdapter)) {
                return Intrinsics.areEqual(this.function, ((FunctionAdapter) obj).getFunctionDelegate());
            }
            return false;
        }

        @Override
        @NotNull
        public final kotlin.h<?> getFunctionDelegate() {
            return this.function;
        }

        public final int hashCode() {
            return this.function.hashCode();
        }

        public final void onChanged(Object obj) {
            this.function.invoke(obj);
        }
    }

    public static final class e extends Lambda implements Function0<d0> {
        public e() {
            super(0);
        }

        @Override
        public final d0 invoke() {
            n0 n = n0.n(PaymentStateActivity.this);
            Intrinsics.checkNotNullExpressionValue(n, "getInstance(...)");
            return n;
        }
    }

    public static final void R0(PaymentStateActivity paymentStateActivity) {
        paymentStateActivity.exitedFromJuspay = true;
        if (paymentStateActivity.orderId == 0) {
            return;
        }
        CheckoutApiFactory.getInstance().checkOrderStatus(paymentStateActivity.orderId, new in.hopscotch.android.payment.c(paymentStateActivity));
    }

    public static final void V0(PaymentStateActivity paymentStateActivity, long j2) {
        paymentStateActivity.getClass();
        g.a aVar = new g.a();
        aVar.e(paymentStateActivity.orderId, "ORDER_ID");
        aVar.e(j2, "retries");
        androidx.work.g a2 = aVar.a();
        Intrinsics.checkNotNullExpressionValue(a2, "build(...)");
        paymentStateActivity.payStatusWork = new t.a(PaymentWorker.class).k(a2).i(androidx.work.f.a).b();
        d0 d0Var = (d0) paymentStateActivity.workManager$delegate.getValue();
        f0 f0Var = paymentStateActivity.payStatusWork;
        f0 f0Var2 = null;
        if (f0Var == null) {
            Intrinsics.throwUninitializedPropertyAccessException("payStatusWork");
            f0Var = null;
        }
        d0Var.c(f0Var);
        d0 d0Var2 = (d0) paymentStateActivity.workManager$delegate.getValue();
        f0 f0Var3 = paymentStateActivity.payStatusWork;
        if (f0Var3 == null) {
            Intrinsics.throwUninitializedPropertyAccessException("payStatusWork");
        } else {
            f0Var2 = f0Var3;
        }
        d0Var2.d(f0Var2.a()).observe(paymentStateActivity, new d(new f(paymentStateActivity)));
    }

    public static final void W0(PaymentStateActivity paymentStateActivity) {
        List list;
        paymentStateActivity.getClass();
        try {
            ShoppingBagResponse A = a1.A();
            String str = null;
            if ((A != null ? A.orderDetails : null) != null) {
                ArrayList arrayList = new ArrayList();
                ArrayList arrayList2 = new ArrayList();
                List cartItems = A.cartItems;
                Intrinsics.checkNotNullExpressionValue(cartItems, "cartItems");
                if (!cartItems.isEmpty()) {
                    int size = cartItems.size();
                    for (int i = 0; i < size; i++) {
                        arrayList.add(((ReviewCartItem) cartItems.get(i)).sku);
                        arrayList2.add(((ReviewCartItem) cartItems.get(i)).brandName);
                    }
                }
                CreditPromotionData creditPromotionData = A.creditPromotionData;
                if (creditPromotionData != null && (list = creditPromotionData.orderPromocodes) != null && list.size() > 0) {
                    str = ((PromoItem) A.creditPromotionData.orderPromocodes.get(0)).code;
                }
                String str2 = str;
                in.hopscotch.android.analytics.facebook.a aVar = HsApplication.b().c;
                String obj = arrayList.toString();
                Intrinsics.checkNotNullExpressionValue(obj, "toString(...)");
                String obj2 = arrayList2.toString();
                Intrinsics.checkNotNullExpressionValue(obj2, "toString(...)");
                OrderDetails orderDetails = A.orderDetails;
                aVar.g(obj, obj2, orderDetails.itemCount, orderDetails.totalAmount, str2);
            }
        } catch (Exception e2) {
            in.hopscotch.android.util.g.b(e2);
        }
    }

    public static final void X0(PaymentStateActivity paymentStateActivity, OrderConfirmationResponse orderConfirmationResponse) {
        TotalOrderAmount totalOrderAmount;
        paymentStateActivity.getClass();
        HashMap hashMap = new HashMap();
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put(PaymentConstants.ORDER_ID, Integer.valueOf(orderConfirmationDetails.orderId));
            hashMap.put("order_bar_code", orderConfirmationResponse.orderDetails.orderBarCode);
        }
        OrderSummary orderSummary = orderConfirmationResponse.orderSummary;
        if (orderSummary != null && (totalOrderAmount = orderSummary.totalOrderAmount) != null) {
            hashMap.put("revenue", totalOrderAmount.value);
        }
        hashMap.put("currency", "INR");
        if (a1.A() != null) {
            ShoppingBagResponse A = a1.A();
            Intrinsics.checkNotNullExpressionValue(A, "getShoppingBagResponse(...)");
            ArrayList arrayList = new ArrayList();
            int size = A.cartItems.size();
            for (int i = 0; i < size; i++) {
                Object obj = A.cartItems.get(i);
                Intrinsics.checkNotNullExpressionValue(obj, "get(...)");
                ReviewCartItem reviewCartItem = (ReviewCartItem) obj;
                int i2 = reviewCartItem.productId;
                StringBuilder sb = new StringBuilder();
                sb.append(i2);
                Properties.Product product = new Properties.Product(sb.toString(), reviewCartItem.sku, reviewCartItem.orderPrice * reviewCartItem.quantity);
                product.put("quantity", Integer.valueOf(reviewCartItem.quantity));
                product.put("name", reviewCartItem.productName);
                product.put("brand", reviewCartItem.brandName);
                arrayList.add(product);
            }
            hashMap.put("products", arrayList);
        }
        v1.f("Order Completed", hashMap, false, false);
    }

    public static final void Y0(PaymentStateActivity paymentStateActivity, OrderConfirmationResponse orderConfirmationResponse) {
        List list;
        paymentStateActivity.getClass();
        HashMap hashMap = new HashMap();
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put(PaymentConstants.ORDER_ID, Integer.valueOf(orderConfirmationDetails.orderId));
            if (orderConfirmationResponse.orderDetails.firstOrder) {
                hashMap.put("first_order", "Yes");
            }
            hashMap.put("discount", Double.valueOf(orderConfirmationDetails.discount));
            hashMap.put("discount_percentage", Double.valueOf(orderConfirmationDetails.discountPercentage));
            hashMap.put("promotion_discount", Double.valueOf(orderConfirmationDetails.promoDiscount));
            hashMap.put("promo_code", orderConfirmationDetails.promoCode);
            hashMap.put("total_amount", Double.valueOf(orderConfirmationDetails.totalAmount));
            hashMap.put("shipping", Double.valueOf(orderConfirmationDetails.shipping));
            hashMap.put("total_quantity", Integer.valueOf(orderConfirmationDetails.totalQuantity));
            hashMap.put("total_item_price", Double.valueOf(orderConfirmationDetails.productAmount));
            hashMap.put("net_amount", Double.valueOf(orderConfirmationDetails.payAmount));
            hashMap.put("sku_count", Integer.valueOf(orderConfirmationDetails.itemCount));
            hashMap.put("credit", Double.valueOf(orderConfirmationDetails.totalCredit));
        }
        PaymentDetails paymentDetails = orderConfirmationResponse.paymentDetails;
        if (paymentDetails != null) {
            hashMap.put("payment_mode", paymentDetails.paymentMethod);
        }
        AllAddressItem allAddressItem = orderConfirmationResponse.address;
        if (allAddressItem != null) {
            hashMap.put("delivery_city", allAddressItem.city);
            hashMap.put("state", allAddressItem.state);
            hashMap.put("pincode", allAddressItem.zipCode);
        }
        if (((ActionResponse) orderConfirmationResponse).messageBar != null) {
            hashMap.put("message_count", "1");
            String[] strArr = new String[((ActionResponse) orderConfirmationResponse).messageBars.size()];
            strArr[0] = ((ActionResponse) orderConfirmationResponse).messageBar.message;
            hashMap.put("message_bar", strArr);
        } else {
            List list2 = ((ActionResponse) orderConfirmationResponse).messageBars;
            if (list2 != null) {
                hashMap.put("message_count", Integer.valueOf(list2.size()));
                String[] strArr2 = new String[((ActionResponse) orderConfirmationResponse).messageBars.size()];
                int size = ((ActionResponse) orderConfirmationResponse).messageBars.size();
                for (int i = 0; i < size; i++) {
                    strArr2[i] = ((MessageBar) ((ActionResponse) orderConfirmationResponse).messageBars.get(i)).message;
                }
                hashMap.put("message_bar", strArr2);
            } else {
                hashMap.put("message_count", "0");
                hashMap.put("message_bar", "none");
            }
        }
        Header header = orderConfirmationResponse.header;
        if (header != null && (list = header.items) != null && list.size() >= 1 && orderConfirmationResponse.header.items.get(1) != null) {
            hashMap.put("banner", ((HeaderItem) orderConfirmationResponse.header.items.get(1)).action);
        }
        if (paymentStateActivity.getIntent().hasExtra("addressType") && !TextUtils.isEmpty(paymentStateActivity.getIntent().getStringExtra("addressType"))) {
            hashMap.put("address", String.valueOf(paymentStateActivity.getIntent().getStringExtra("addressType")));
        }
        if (hashMap.containsKey("payment_mode") && !TextUtils.isEmpty((String) hashMap.get("payment_mode")) && Intrinsics.areEqual((String) hashMap.get("payment_mode"), "CARD")) {
            hashMap.put("payment_mode", "Card");
        }
        hashMap.put("paymentOffersActive", Boolean.valueOf(orderConfirmationResponse.paymentOffersActive));
        OrderConfirmationDetails orderConfirmationDetails2 = orderConfirmationResponse.orderDetails;
        List list3 = orderConfirmationDetails2 != null ? orderConfirmationDetails2.promoApplied : null;
        if (list3 != null && !list3.isEmpty()) {
            List promoApplied = orderConfirmationResponse.orderDetails.promoApplied;
            Intrinsics.checkNotNullExpressionValue(promoApplied, "promoApplied");
            hashMap.put("promoApplied", in.hopscotch.android.core.util.a.b(in.hopscotch.android.core.util.a.a(promoApplied)));
        }
        in.hopscotch.android.analytics.c.m().getClass();
        HashMap c2 = in.hopscotch.android.analytics.c.c(true);
        Intrinsics.checkNotNullExpressionValue(c2, "addUserTypeAndDuration(...)");
        hashMap.putAll(c2);
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I("order_placed", hashMap, false, false);
    }

    public static final void Z0(PaymentStateActivity paymentStateActivity, OrderConfirmationResponse orderConfirmationResponse) {
        paymentStateActivity.getClass();
        HashMap hashMap = new HashMap();
        PaymentDetails paymentDetails = orderConfirmationResponse.paymentDetails;
        if (paymentDetails != null) {
            hashMap.put("payment_mode", paymentDetails.paymentMethod);
        }
        AllAddressItem allAddressItem = orderConfirmationResponse.address;
        if (allAddressItem != null) {
            hashMap.put("delivery_city", allAddressItem.city);
            hashMap.put("state", orderConfirmationResponse.address.state);
            hashMap.put("pincode", orderConfirmationResponse.address.zipCode);
        }
        if (!TextUtils.isEmpty(in.hopscotch.android.db.a.h())) {
            hashMap.put("checkout_user", in.hopscotch.android.db.a.h());
        }
        if (hashMap.containsKey("payment_mode") && !TextUtils.isEmpty((String) hashMap.get("payment_mode")) && Intrinsics.areEqual((String) hashMap.get("payment_mode"), "CARD")) {
            hashMap.put("payment_mode", "Card");
        }
        hashMap.put("step_duration", Long.valueOf(in.hopscotch.android.helper.a.c(true)));
        hashMap.put("total_duration", Long.valueOf(in.hopscotch.android.helper.a.b()));
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put(PaymentConstants.ORDER_ID, Integer.valueOf(orderConfirmationDetails.orderId));
            if (orderConfirmationResponse.orderDetails.firstOrder) {
                hashMap.put("first_order", "Yes");
            }
            List list = orderConfirmationResponse.orderDetails.items;
            if (list != null) {
                int size = list.size();
                for (int i = 0; i < size; i++) {
                    HashMap hashMap2 = new HashMap();
                    hashMap2.put("product_id", Integer.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).productId));
                    hashMap2.put("sku", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).sku);
                    hashMap2.put("price", Double.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).retailPrice));
                    hashMap2.put("mrp", Double.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).regularPrice));
                    hashMap2.put("discount_percentage", Integer.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).discountPercentage));
                    hashMap2.put("quantity", Integer.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).quantity));
                    hashMap2.put("revenue", Double.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).priceAfterAllDiscount));
                    hashMap2.put("delivery_days", Integer.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).deliveryDays));
                    hashMap2.put("name", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).productName);
                    hashMap2.put("category", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).category);
                    hashMap2.put("subcategory", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).subcategory);
                    hashMap2.put("product_type", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).productType);
                    hashMap2.put("subproduct_type", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).subProductType);
                    hashMap2.put("brand", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).brandName);
                    hashMap2.put("gender", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).gender);
                    hashMap2.put("from_age", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).fromAge);
                    hashMap2.put("to_age", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).toAge);
                    hashMap2.put("preorder", Boolean.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).isPresale));
                    hashMap2.put("sale", Boolean.valueOf(((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).onSale));
                    hashMap2.put("colour", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).color);
                    hashMap2.put("size", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).size);
                    hashMap2.put("image_url", ((ReviewCartItem) orderConfirmationResponse.orderDetails.items.get(i)).imgSrc);
                    Intrinsics.checkNotNull(hashMap2);
                    hashMap.putAll(hashMap2);
                    if (!TextUtils.isEmpty((String) hashMap.get("sku"))) {
                        String str = (String) hashMap.get("sku");
                        in.hopscotch.android.analytics.c.m().getClass();
                        HashMap f0 = in.hopscotch.android.analytics.c.f0(str);
                        if (f0.size() > 0) {
                            hashMap.putAll(f0);
                        }
                    }
                    in.hopscotch.android.analytics.c.m().getClass();
                    in.hopscotch.android.analytics.c.I("product_ordered", hashMap, false, false);
                }
            }
        }
    }

    public static final void a1(PaymentStateActivity paymentStateActivity, JSONObject jSONObject) {
        paymentStateActivity.getClass();
        if (jSONObject != null) {
            String optString = jSONObject.optString("label");
            JSONObject optJSONObject = jSONObject.optJSONObject("value");
            if (optJSONObject != null) {
                Intrinsics.checkNotNull(optJSONObject);
                LinkedHashMap k = s0.k(j1.j(optJSONObject));
                HashMap e1 = e1();
                if (!e1.isEmpty()) {
                    k.putAll(e1);
                }
                in.hopscotch.android.analytics.c.m().getClass();
                HashMap c2 = in.hopscotch.android.analytics.c.c(true);
                Intrinsics.checkNotNullExpressionValue(c2, "addUserTypeAndDuration(...)");
                k.putAll(c2);
                in.hopscotch.android.analytics.c.m().getClass();
                in.hopscotch.android.analytics.c.I(optString, k, true, true);
            }
        }
    }

    public static final void b1(PaymentStateActivity paymentStateActivity, PaymentState paymentState, Error error, String str) {
        int i;
        if (error != null) {
            paymentStateActivity.getClass();
            g1(error, str);
            Intent intent = new Intent();
            intent.putExtra("errorData", (Serializable) error);
            paymentStateActivity.setResult(1997, intent);
            paymentStateActivity.finish();
            return;
        }
        if (paymentState == null) {
            i = -1;
        } else {
            paymentStateActivity.getClass();
            i = a.a[paymentState.ordinal()];
        }
        if (i == 1) {
            paymentStateActivity.f1();
            return;
        }
        if (i == 2) {
            paymentStateActivity.getClass();
            g1(error, str);
            paymentStateActivity.i1();
        } else {
            if (i != 3) {
                paymentStateActivity.i1();
                return;
            }
            paymentStateActivity.getClass();
            h1(error, str);
            paymentStateActivity.i1();
        }
    }

    public static HashMap e1() {
        ?? orderPromocodes;
        ?? orderPromocodes2;
        ShoppingBagResponse A = a1.A();
        HashMap hashMap = new HashMap();
        if (A == null) {
            return hashMap;
        }
        OrderDetails orderDetails = A.orderDetails;
        if (orderDetails != null) {
            double d2 = orderDetails.discount;
            if (d2 > 0.0d) {
                hashMap.put("discount", Double.valueOf(d2));
            }
            double d3 = A.orderDetails.discountPercentage;
            if (d3 > 0.0d) {
                hashMap.put("discount_percentage", Double.valueOf(d3));
            }
            double d4 = A.orderDetails.shipping;
            if (d4 > 0.0d) {
                hashMap.put("shipping", Double.valueOf(d4));
            } else {
                hashMap.put("shipping", 0);
            }
            ArrayList arrayList = new ArrayList();
            CreditPromotionData creditPromotionData = A.creditPromotionData;
            if (creditPromotionData == null || (orderPromocodes2 = creditPromotionData.orderPromocodes) == 0) {
                PromotionData promotionData = A.promotionData;
                if (promotionData != null && (orderPromocodes = promotionData.orderPromocodes) != 0) {
                    Intrinsics.checkNotNullExpressionValue(orderPromocodes, "orderPromocodes");
                    arrayList = orderPromocodes;
                }
            } else {
                Intrinsics.checkNotNullExpressionValue(orderPromocodes2, "orderPromocodes");
                arrayList = orderPromocodes2;
            }
            if (!arrayList.isEmpty()) {
                int size = arrayList.size();
                for (int i = 0; i < size; i++) {
                    if (((PromoItem) arrayList.get(i)).applied && !TextUtils.isEmpty(((PromoItem) arrayList.get(i)).code) && ((PromoItem) arrayList.get(i)).discount > 0.0d) {
                        String code = ((PromoItem) arrayList.get(i)).code;
                        Intrinsics.checkNotNullExpressionValue(code, "code");
                        hashMap.put("promo_code", code);
                        hashMap.put("promotion_discount", Double.valueOf(((PromoItem) arrayList.get(i)).discount));
                    }
                }
            }
        }
        return hashMap;
    }

    public static void g1(Error error, String str) {
        HashMap q = android.support.v4.media.c.q("from_screen", "Checkout");
        q.put("error", error != null ? error.getErrorMessage() : null);
        q.put("payment_mode", str);
        HashMap e1 = e1();
        if (!e1.isEmpty()) {
            q.putAll(e1);
        }
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.Q("order_failed", q, false);
    }

    public static void h1(Error error, String str) {
        HashMap q = android.support.v4.media.c.q("from_screen", "Payment Processing");
        q.put("error", error != null ? error.getErrorMessage() : null);
        q.put("payment_mode", str);
        HashMap e1 = e1();
        if (!e1.isEmpty()) {
            q.putAll(e1);
        }
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.Q("order_pending", q, false);
    }

    @Override
    public final void b() {
        in.hopscotch.android.payment.b bVar = this.paymentFragment;
        if (bVar != null) {
            bVar.dismissAllowingStateLoss();
        }
        ((d0) this.workManager$delegate.getValue()).a();
        this.exitedFromJuspay = true;
        Intent intent = new Intent();
        intent.putExtra("ORDER_ID", this.orderId);
        setResult(2000, intent);
        finish();
    }

    public final void f1() {
        CustomerInfoApiFactory.getInstance().getOrderConfirmation(this.orderId, new in.hopscotch.android.payment.e(this));
    }

    public final void i1() {
        OrdersMainActivity.a aVar = OrdersMainActivity.j;
        OrdersMainActivity.b bVar = OrdersMainActivity.b.LISTING;
        aVar.getClass();
        Intent a2 = OrdersMainActivity.a.a(this, "Checkout", false, bVar);
        a2.putExtra("FROM_CHECKOUT", true);
        a2.setFlags(335577088);
        startActivity(a2);
        finish();
    }

    public final void onActivityResult(int i, int i2, Intent intent) {
        HyperServices hyperServices;
        super/*androidx.fragment.app.n*/.onActivityResult(i, i2, intent);
        HyperServiceHolder hyperServiceHolder = this.hyperServicesHolder;
        if (hyperServiceHolder == null || (hyperServices = hyperServiceHolder.getHyperServices()) == null) {
            return;
        }
        hyperServices.onActivityResult(i, i2, intent);
    }

    public final void onCreate(Bundle bundle) {
        super/*androidx.fragment.app.n*/.onCreate(bundle);
        LayoutInflater layoutInflater = getLayoutInflater();
        int i = q1.e;
        p pVar = (q1) p.M(layoutInflater, 2131558490, (ViewGroup) null, false, androidx.databinding.g.e());
        Intrinsics.checkNotNullExpressionValue(pVar, "inflate(...)");
        Intrinsics.checkNotNullParameter(pVar, "<set-?>");
        this.i = pVar;
        if (pVar == null) {
            Intrinsics.throwUninitializedPropertyAccessException("binding");
            pVar = null;
        }
        setContentView(pVar.E());
        q1 q1Var = this.i;
        if (q1Var == null) {
            Intrinsics.throwUninitializedPropertyAccessException("binding");
            q1Var = null;
        }
        setSupportActionBar(q1Var.d);
        androidx.appcompat.app.a supportActionBar = getSupportActionBar();
        if (supportActionBar != null) {
            supportActionBar.t(true);
            supportActionBar.w();
            supportActionBar.x(false);
        }
        androidx.activity.d0 onBackPressedDispatcher = getOnBackPressedDispatcher();
        b onBackPressedCallback = this.onBackPressedCallback;
        onBackPressedDispatcher.getClass();
        Intrinsics.checkNotNullParameter(onBackPressedCallback, "onBackPressedCallback");
        onBackPressedDispatcher.g(onBackPressedCallback);
        InitJusPayResponse serializableExtra = getIntent().getSerializableExtra("juspayResponse");
        Intrinsics.checkNotNull(serializableExtra, "null cannot be cast to non-null type in.hopscotch.android.api.response.InitJusPayResponse");
        this.jusPayResponse = serializableExtra;
        this.orderId = getIntent().getLongExtra("ORDER_ID", 0L);
        HyperServiceHolder hyperServiceHolder = new HyperServiceHolder(this);
        this.hyperServicesHolder = hyperServiceHolder;
        hyperServiceHolder.setCallback(new in.hopscotch.android.payment.d(this));
        BuildersKt__Builders_commonKt.launch$default(LifecycleOwnerKt.getLifecycleScope(this), null, null, new c(null), 3, null);
    }

    public final boolean onOptionsItemSelected(@NotNull MenuItem item) {
        Intrinsics.checkNotNullParameter(item, "item");
        if (item.getItemId() == 16908332) {
            this.onBackPressedCallback.d();
        }
        return super/*android.app.Activity*/.onOptionsItemSelected(item);
    }
}