Swiggy v4.51.1版本的 MD5 值为:5af7ec91512a0a8c1510e3f8bac20b8b

以下内容为反编译后的 OTPFragmentViewModel.java 源代码,内容仅作参考


package in.swiggy.android.onboarding.viewmodel;

import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.CountDownTimer;
import androidx.compose.runtime.l2;
import androidx.compose.runtime.y0;
import androidx.databinding.ObservableBoolean;
import androidx.databinding.ObservableField;
import androidx.databinding.j;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.l0;
import androidx.lifecycle.y;
import com.appsflyer.AppsFlyerProperties;
import com.google.android.gms.auth.api.phone.SmsRetriever;
import com.payu.threeDS2.constants.LoggingConstants;
import com.payu.threedsbase.constants.APIConstants;
import com.swiggy.tns.duplix.v1.CloningSignalsProto;
import in.swiggy.android.R;
import in.swiggy.android.SwiggyApplication;
import in.swiggy.android.activities.LoginLimitErrorActivity;
import in.swiggy.android.commons.extension.KotlinExtensionsKt;
import in.swiggy.android.commons.utils.DispatchProviderKt;
import in.swiggy.android.commons.utils.x;
import in.swiggy.android.dls.button.ButtonType;
import in.swiggy.android.feature.address.LoginAddressSyncKt;
import in.swiggy.android.mvvm.aarch.CoreViewModel;
import in.swiggy.android.mvvm.viewmodels.loginsignup.ForgotPasswordOTPViewModel;
import in.swiggy.android.network.interceptors.p;
import in.swiggy.android.onboarding.c;
import in.swiggy.android.tejas.Response;
import in.swiggy.android.tejas.TejasConstants;
import in.swiggy.android.tejas.api.models.SwiggyApiResponse;
import in.swiggy.android.tejas.api.models.SwiggyBaseResponse;
import in.swiggy.android.tejas.error.Error;
import in.swiggy.android.tejas.feature.address.model.Address;
import in.swiggy.android.tejas.feature.address.model.AllAddress;
import in.swiggy.android.tejas.feature.address.v2.usecase.GetAllAddressUseCase;
import in.swiggy.android.tejas.feature.auth.OtpVerifyUseCaseV3;
import in.swiggy.android.tejas.feature.otprequest.usecase.CallVerificationStatusUseCase;
import in.swiggy.android.tejas.feature.otprequest.usecase.RequestCallVerificationUseCase;
import in.swiggy.android.tejas.feature.otprequest.usecase.RequestSmsOtpUseCase;
import in.swiggy.android.tejas.feature.otprequest.usecase.RequestWhatsappOtpUseCase;
import in.swiggy.android.tejas.oldapi.network.responses.UserResponseData;
import in.swiggy.android.utils.GeneralExtensionsKt;
import in.swiggy.android.utils.i0;
import io.reactivex.processors.PublishProcessor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import kotlin.Unit;
import kotlin.coroutines.CoroutineContext;
import kotlin.coroutines.jvm.internal.ContinuationImpl;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.text.StringsKt__StringsKt;
import kotlinx.coroutines.f0;
import kotlinx.coroutines.q1;
import kotlinx.coroutines.v0;
import org.json.JSONObject;
public class OTPFragmentViewModel extends CoreViewModel {
    public static final a X0 = new a(null);
    public static final int Y0 = 8;
    private static final String Z0;
    public ObservableField<String> A;
    private q1 A0;
    public ObservableField<String> B;
    private boolean B0;
    public ObservableField<String> C;
    private boolean C0;
    public ObservableField<String> D;
    private boolean D0;
    public ObservableField<String> E;
    private ObservableBoolean E0;
    public ObservableField<String> F;
    private ObservableBoolean F0;
    public ObservableField<String> G;
    private ObservableBoolean G0;
    public ObservableField<String> H;
    private ObservableBoolean H0;
    public ObservableField<String> I;
    private ObservableBoolean I0;
    private final in.swiggy.android.commons.validation.f<String> J;
    private ObservableBoolean J0;
    public ObservableField<String> K;
    private ObservableBoolean K0;
    public ObservableField<Boolean> L;
    private boolean L0;
    public ObservableField<Integer> M;
    private ObservableBoolean M0;
    public in.swiggy.android.repositories.interfaces.e N;
    private ObservableBoolean N0;
    private CountDownTimer O;
    private UserResponseData O0;
    private boolean P;
    private boolean P0;
    private boolean Q;
    private ArrayList<String> Q0;
    private final int R;
    private final y0 R0;
    private io.reactivex.disposables.a S;
    private final y0 S0;
    private io.reactivex.disposables.b T;
    private final y0 T0;
    private boolean U;
    private String U0;
    private final y<in.swiggy.android.commons.utils.l<in.swiggy.android.onboarding.c>> V;
    private final kotlin.j V0;
    private final LiveData<in.swiggy.android.commons.utils.l<in.swiggy.android.onboarding.c>> W;
    private ObservableBoolean W0;
    private final y<Boolean> X;
    private final LiveData<Boolean> Y;
    private final ObservableBoolean Z;
    private final ObservableBoolean c0;
    private final OtpVerifyUseCaseV3 e;
    private final RequestSmsOtpUseCase f;
    private final RequestWhatsappOtpUseCase g;
    private final RequestCallVerificationUseCase h;
    private final CallVerificationStatusUseCase i;
    private final SwiggyApplication j;
    private final GetAllAddressUseCase k;
    public in.swiggy.android.mvvm.services.s l;
    public SharedPreferences m;
    public in.swiggy.android.commons.utils.contextservice.h n;
    public in.swiggy.android.analytics.generated.e o;
    public in.swiggy.android.analytics.interfaces.c p;
    private final ObservableBoolean p0;
    public in.swiggy.android.analytics.newrelic.a q;
    public in.swiggy.android.repositories.interfaces.d r;
    public in.swiggy.android.repositories.interfaces.e s;
    public PublishProcessor<Integer> t;
    private String u;
    private String v;
    private String w;
    private boolean x;
    private String y;
    public ObservableBoolean y0;
    public ObservableField<Boolean> z;
    public ObservableBoolean z0;

    public static final class Loader {
        private static final kotlin.enums.a $ENTRIES;
        private static final Loader[] $VALUES;
        public static final Loader OtpVerify = new Loader("OtpVerify", 0);
        public static final Loader SmsRetry = new Loader("SmsRetry", 1);
        public static final Loader CallRetry = new Loader("CallRetry", 2);
        public static final Loader WhatsApp = new Loader("WhatsApp", 3);

        private static final Loader[] $values() {
            return new Loader[]{OtpVerify, SmsRetry, CallRetry, WhatsApp};
        }

        static {
            Loader[] $values = $values();
            $VALUES = $values;
            $ENTRIES = kotlin.enums.b.a($values);
        }

        private Loader(String str, int i) {
        }

        public static kotlin.enums.a<Loader> getEntries() {
            return $ENTRIES;
        }

        public static Loader valueOf(String str) {
            return (Loader) Enum.valueOf(Loader.class, str);
        }

        public static Loader[] values() {
            return (Loader[]) $VALUES.clone();
        }
    }

    public static final class a {
        public a(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        private a() {
        }
    }

    public static final class b extends CountDownTimer {
        final String b;
        final String c;

        b(String str, String str2, long j) {
            super(j, 1000L);
            this.b = str;
            this.c = str2;
        }

        @Override
        public void onFinish() {
            if (!OTPFragmentViewModel.this.M7().g() && !OTPFragmentViewModel.this.Q8()) {
                OTPFragmentViewModel.this.O9();
            }
            OTPFragmentViewModel.this.aa(this.c);
            OTPFragmentViewModel.this.J7();
            OTPFragmentViewModel.this.G().d(ForgotPasswordOTPViewModel.class, OTPFragmentViewModel.this.r0().getString(R.string.timer_expired));
            OTPFragmentViewModel.this.M.h(2);
        }

        @Override
        public void onTick(long j) {
            long j2 = j / 1000;
            OTPFragmentViewModel oTPFragmentViewModel = OTPFragmentViewModel.this;
            kotlin.jvm.internal.v vVar = kotlin.jvm.internal.v.a;
            String format = String.format(this.b, Arrays.copyOf(new Object[]{Long.valueOf(j2)}, 1));
            kotlin.jvm.internal.o.j(format, "format(...)");
            oTPFragmentViewModel.aa(format);
            OTPFragmentViewModel.this.E7((int) j2);
        }
    }

    public static final class c extends kotlin.coroutines.a implements f0 {
        public c(f0.a aVar) {
            super(aVar);
        }

        @Override
        public void L(CoroutineContext coroutineContext, Throwable th) {
            x.i(OTPFragmentViewModel.Z0, th);
        }
    }

    public static final class d extends j.a {
        d() {
        }

        @Override
        public void d(androidx.databinding.j sender, int i) {
            kotlin.jvm.internal.o.k(sender, "sender");
            OTPFragmentViewModel.this.w9();
        }
    }

    public static final class e extends j.a {
        e() {
        }

        @Override
        public void d(androidx.databinding.j sender, int i) {
            kotlin.jvm.internal.o.k(sender, "sender");
            if (!kotlin.jvm.internal.o.f(OTPFragmentViewModel.this.L.g(), Boolean.TRUE)) {
                OTPFragmentViewModel.this.Q = true;
            }
        }
    }

    public static final class f extends j.a {
        f() {
        }

        @Override
        public void d(androidx.databinding.j sender, int i) {
            kotlin.jvm.internal.o.k(sender, "sender");
            if (OTPFragmentViewModel.this.c8().b(OTPFragmentViewModel.this.G.g())) {
                if (!OTPFragmentViewModel.this.e8()) {
                    OTPFragmentViewModel.this.z.h(Boolean.TRUE);
                }
                OTPFragmentViewModel.this.H.h(null);
                return;
            }
            OTPFragmentViewModel.this.C9(false);
            OTPFragmentViewModel.this.z.h(Boolean.FALSE);
            OTPFragmentViewModel oTPFragmentViewModel = OTPFragmentViewModel.this;
            oTPFragmentViewModel.H.h(oTPFragmentViewModel.c8().a());
        }
    }

    static {
        String simpleName = OTPFragmentViewModel.class.getSimpleName();
        kotlin.jvm.internal.o.j(simpleName, "getSimpleName(...)");
        Z0 = simpleName;
    }

    public OTPFragmentViewModel(OtpVerifyUseCaseV3 otpVerifyUseCase, RequestSmsOtpUseCase requestSmsOtpUseCase, RequestWhatsappOtpUseCase requestWhatsappOtpUseCase, RequestCallVerificationUseCase requestCallVerificationUseCase, CallVerificationStatusUseCase callVerificationStatusUseCase, SwiggyApplication application, GetAllAddressUseCase getAllAddressUseCase) {
        y0 e2;
        y0 e3;
        y0 e4;
        kotlin.j b2;
        kotlin.jvm.internal.o.k(otpVerifyUseCase, "otpVerifyUseCase");
        kotlin.jvm.internal.o.k(requestSmsOtpUseCase, "requestSmsOtpUseCase");
        kotlin.jvm.internal.o.k(requestWhatsappOtpUseCase, "requestWhatsappOtpUseCase");
        kotlin.jvm.internal.o.k(requestCallVerificationUseCase, "requestCallVerificationUseCase");
        kotlin.jvm.internal.o.k(callVerificationStatusUseCase, "callVerificationStatusUseCase");
        kotlin.jvm.internal.o.k(application, "application");
        kotlin.jvm.internal.o.k(getAllAddressUseCase, "getAllAddressUseCase");
        this.e = otpVerifyUseCase;
        this.f = requestSmsOtpUseCase;
        this.g = requestWhatsappOtpUseCase;
        this.h = requestCallVerificationUseCase;
        this.i = callVerificationStatusUseCase;
        this.j = application;
        this.k = getAllAddressUseCase;
        Boolean bool = Boolean.FALSE;
        this.z = new ObservableField<>(bool);
        this.A = new ObservableField<>("");
        this.B = new ObservableField<>("");
        this.C = new ObservableField<>("");
        this.D = new ObservableField<>("");
        this.E = new ObservableField<>("");
        this.F = new ObservableField<>("");
        this.G = new ObservableField<>("");
        this.H = new ObservableField<>();
        this.I = new ObservableField<>();
        this.J = new in.swiggy.android.commons.validation.f<>(null);
        this.K = new ObservableField<>("");
        this.L = new ObservableField<>(bool);
        this.M = new ObservableField<>(1);
        this.Q = true;
        this.R = 4;
        this.S = new io.reactivex.disposables.a();
        y<in.swiggy.android.commons.utils.l<in.swiggy.android.onboarding.c>> yVar = new y<>();
        this.V = yVar;
        this.W = yVar;
        y<Boolean> yVar2 = new y<>();
        this.X = yVar2;
        this.Y = yVar2;
        this.Z = new ObservableBoolean(false);
        this.c0 = new ObservableBoolean(false);
        this.p0 = new ObservableBoolean(false);
        this.y0 = new ObservableBoolean(false);
        this.z0 = new ObservableBoolean(false);
        this.E0 = new ObservableBoolean(false);
        this.F0 = new ObservableBoolean(false);
        this.G0 = new ObservableBoolean(false);
        this.H0 = new ObservableBoolean(false);
        this.I0 = new ObservableBoolean(false);
        this.J0 = new ObservableBoolean(false);
        this.K0 = new ObservableBoolean(false);
        this.M0 = new ObservableBoolean(false);
        this.N0 = new ObservableBoolean(false);
        e2 = l2.e(bool, null, 2, null);
        this.R0 = e2;
        e3 = l2.e(bool, null, 2, null);
        this.S0 = e3;
        e4 = l2.e("", null, 2, null);
        this.T0 = e4;
        this.U0 = "Sms-manual";
        b2 = kotlin.l.b(new Function0<in.swiggy.android.dls.button.a>() {
            {
                super(0);
            }

            @Override
            public final in.swiggy.android.dls.button.a invoke() {
                return new in.swiggy.android.dls.button.a(ButtonType.Primary, OTPFragmentViewModel.this.r0().getString(R.string.continue_text), null, null, true);
            }
        });
        this.V0 = b2;
        this.W0 = new ObservableBoolean(false);
    }

    private final void B7() {
        io.reactivex.disposables.a aVar = this.S;
        io.reactivex.d<String> P = Z7().p().P(io.reactivex.android.schedulers.a.a());
        final Function1<String, Unit> function1 = new Function1<String, Unit>() {
            {
                super(1);
            }

            @Override
            public Unit invoke(String str) {
                invoke2(str);
                return Unit.a;
            }

            public final void invoke2(String str) {
                if (OTPFragmentViewModel.this.Z7().F() || !OTPFragmentViewModel.this.c8().b(str)) {
                    OTPFragmentViewModel oTPFragmentViewModel = OTPFragmentViewModel.this;
                    oTPFragmentViewModel.P9(oTPFragmentViewModel.r0().getString(R.string.something_went_wrong_try_again));
                    return;
                }
                OTPFragmentViewModel oTPFragmentViewModel2 = OTPFragmentViewModel.this;
                kotlin.jvm.internal.o.h(str);
                oTPFragmentViewModel2.p9(str);
            }
        };
        io.reactivex.functions.d<? super String> dVar = new io.reactivex.functions.d() {
            @Override
            public final void accept(Object obj) {
                OTPFragmentViewModel.C7(Function1.this, obj);
            }
        };
        final OTPFragmentViewModel$addSubscriptionForWhatsappOtpFromDeeplink$2 oTPFragmentViewModel$addSubscriptionForWhatsappOtpFromDeeplink$2 = new Function1<Throwable, Unit>() {
            @Override
            public Unit invoke(Throwable th) {
                invoke2(th);
                return Unit.a;
            }

            public final void invoke2(Throwable th) {
                x.i(OTPFragmentViewModel.Z0, th);
            }
        };
        aVar.c(P.g0(dVar, new io.reactivex.functions.d() {
            @Override
            public final void accept(Object obj) {
                OTPFragmentViewModel.D7(Function1.this, obj);
            }
        }));
    }

    public final void B8(SwiggyBaseResponse swiggyBaseResponse) {
        Integer num;
        String string;
        String string2;
        String str;
        String str2 = null;
        if (swiggyBaseResponse != null) {
            num = swiggyBaseResponse.getStatusCode();
        } else {
            num = null;
        }
        if (swiggyBaseResponse != null) {
            str2 = swiggyBaseResponse.getStatusMessage();
        }
        String str3 = str2;
        boolean z = true;
        if (num != null && num.intValue() == 1) {
            string = r0().getString(R.string.call_not_placed_try_later);
        } else if (num != null && num.intValue() == 9) {
            this.M0.h(true);
            string2 = r0().getString(R.string.verification_limit_exceeded_try_later);
            z = false;
            if (str3 != null) {
                str = string2;
            } else {
                str = str3;
            }
            i9(str, z);
            Y8(num, str3, string2, "call", "send");
        } else if (num != null && num.intValue() == 400) {
            string = r0().getString(R.string.invalid_mobile_number);
        } else {
            string = r0().getString(R.string.verification_via_call_failed);
            J7();
        }
        string2 = string;
        if (str3 != null) {
        }
        i9(str, z);
        Y8(num, str3, string2, "call", "send");
    }

    private final void B9(boolean z) {
        this.S0.setValue(Boolean.valueOf(z));
    }

    public static final void C7(Function1 tmp0, Object obj) {
        kotlin.jvm.internal.o.k(tmp0, "$tmp0");
        tmp0.invoke(obj);
    }

    public static final void D7(Function1 tmp0, Object obj) {
        kotlin.jvm.internal.o.k(tmp0, "$tmp0");
        tmp0.invoke(obj);
    }

    public final void D8(SwiggyBaseResponse swiggyBaseResponse, String str) {
        Integer num;
        String str2;
        String str3 = null;
        if (swiggyBaseResponse != null) {
            num = swiggyBaseResponse.getStatusCode();
        } else {
            num = null;
        }
        if (swiggyBaseResponse != null) {
            str3 = swiggyBaseResponse.getStatusMessage();
        }
        String str4 = str3;
        boolean z = true;
        if (num != null && num.intValue() == 9) {
            this.M0.h(true);
            z = false;
        } else if (num == null || num.intValue() != 400) {
            J7();
        }
        String b8 = b8(num);
        if (str4 == null) {
            str2 = b8;
        } else {
            str2 = str4;
        }
        i9(str2, z);
        Y8(num, str4, b8, str, "send");
    }

    private final void D9(boolean z) {
        this.R0.setValue(Boolean.valueOf(z));
    }

    public final void E8(SwiggyBaseResponse swiggyBaseResponse, String str, String str2) {
        String str3;
        CharSequence k1;
        p.a aVar = in.swiggy.android.network.interceptors.p.e;
        String tid = swiggyBaseResponse.getTid();
        if (tid != null) {
            k1 = StringsKt__StringsKt.k1(tid);
            str3 = k1.toString();
        } else {
            str3 = null;
        }
        aVar.c(str3, "https://profile.swiggy.comapi/v3/app/sms_otp", Z7());
        ba();
        U9(str, str2);
    }

    public final void F8(SwiggyBaseResponse swiggyBaseResponse, String str, String str2) {
        String str3;
        CharSequence k1;
        p.a aVar = in.swiggy.android.network.interceptors.p.e;
        String tid = swiggyBaseResponse.getTid();
        if (tid != null) {
            k1 = StringsKt__StringsKt.k1(tid);
            str3 = k1.toString();
        } else {
            str3 = null;
        }
        aVar.c(str3, "https://profile.swiggy.comapi/v3/app/whatsapp_otp", Z7());
        U9(str, str2);
    }

    private final void F9(String str) {
        this.T0.setValue(str);
    }

    private final void G8() {
        x.b(Z0, "handleSmsNotVerified: Not verified SMS");
    }

    private final void H7() {
        this.Z.h(false);
        this.c0.h(false);
        this.p0.h(false);
    }

    private final void H8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(c.b.a));
    }

    private final void H9(boolean z) {
        this.z0.h(z);
        if (KotlinExtensionsKt.h(Boolean.valueOf(z))) {
            r9();
        }
    }

    private final void I9() {
        this.H.Y(new d());
        this.L.Y(new e());
        this.H.h(r0().getString(R.string.continue_btn));
        this.G.Y(new f());
    }

    private final void J8() {
        this.E0.h(false);
        this.G0.h(false);
        this.F0.h(false);
        this.I0.h(false);
    }

    private final void K7(String str, String str2) {
        a8().i("otp-verify", str, "status", str2);
        a8().l("otp-verify", str);
    }

    public static final void K8(Function1 tmp0, Object obj) {
        kotlin.jvm.internal.o.k(tmp0, "$tmp0");
        tmp0.invoke(obj);
    }

    public final Object L7(kotlin.coroutines.c<? super Unit> cVar) {
        OTPFragmentViewModel$fetchCallVerificationStatus$1 oTPFragmentViewModel$fetchCallVerificationStatus$1;
        Object f2;
        int i;
        OTPFragmentViewModel oTPFragmentViewModel;
        Response response;
        if (cVar instanceof OTPFragmentViewModel$fetchCallVerificationStatus$1) {
            oTPFragmentViewModel$fetchCallVerificationStatus$1 = (OTPFragmentViewModel$fetchCallVerificationStatus$1) cVar;
            int i2 = oTPFragmentViewModel$fetchCallVerificationStatus$1.d;
            if ((i2 & Integer.MIN_VALUE) != 0) {
                oTPFragmentViewModel$fetchCallVerificationStatus$1.d = i2 - Integer.MIN_VALUE;
                Object obj = oTPFragmentViewModel$fetchCallVerificationStatus$1.b;
                f2 = kotlin.coroutines.intrinsics.b.f();
                i = oTPFragmentViewModel$fetchCallVerificationStatus$1.d;
                SwiggyBaseResponse swiggyBaseResponse = null;
                if (i == 0) {
                    if (i == 1) {
                        oTPFragmentViewModel = (OTPFragmentViewModel) oTPFragmentViewModel$fetchCallVerificationStatus$1.a;
                        kotlin.n.b(obj);
                    } else {
                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                    }
                } else {
                    kotlin.n.b(obj);
                    kotlinx.coroutines.flow.d<Response<SwiggyApiResponse<UserResponseData>>> invoke = this.i.invoke(null);
                    oTPFragmentViewModel$fetchCallVerificationStatus$1.a = this;
                    oTPFragmentViewModel$fetchCallVerificationStatus$1.d = 1;
                    obj = kotlinx.coroutines.flow.f.O(invoke, oTPFragmentViewModel$fetchCallVerificationStatus$1);
                    if (obj == f2) {
                        return f2;
                    }
                    oTPFragmentViewModel = this;
                }
                response = (Response) obj;
                if (!(response instanceof Response.Success)) {
                    oTPFragmentViewModel.w8((SwiggyApiResponse) ((Response.Success) response).getResponse());
                } else if (response instanceof Response.Failure) {
                    Response.Failure failure = (Response.Failure) response;
                    if (failure.getError() instanceof Error.UnhandledExceptionError) {
                        Object response2 = failure.getResponse();
                        if (response2 instanceof SwiggyBaseResponse) {
                            swiggyBaseResponse = (SwiggyBaseResponse) response2;
                        }
                        oTPFragmentViewModel.v8(swiggyBaseResponse);
                    }
                }
                return Unit.a;
            }
        }
        oTPFragmentViewModel$fetchCallVerificationStatus$1 = new OTPFragmentViewModel$fetchCallVerificationStatus$1(this, cVar);
        Object obj2 = oTPFragmentViewModel$fetchCallVerificationStatus$1.b;
        f2 = kotlin.coroutines.intrinsics.b.f();
        i = oTPFragmentViewModel$fetchCallVerificationStatus$1.d;
        SwiggyBaseResponse swiggyBaseResponse2 = null;
        if (i == 0) {
        }
        response = (Response) obj2;
        if (!(response instanceof Response.Success)) {
        }
        return Unit.a;
    }

    private final void L8() {
        boolean z;
        String string = X7().getString("android_reverification_options_list", "[\"otp_via_sms\",\"verify_via_call\"]");
        if (string == null) {
            string = APIConstants.AUTHENTICATION_INFO_VALUE;
        }
        ArrayList<String> f2 = i0.f(string);
        this.Q0 = f2;
        ArrayList<String> arrayList = null;
        if (f2 == null) {
            kotlin.jvm.internal.o.C("verificationOptionsList");
            f2 = null;
        }
        this.B0 = f2.contains("otp_via_sms");
        ArrayList<String> arrayList2 = this.Q0;
        if (arrayList2 == null) {
            kotlin.jvm.internal.o.C("verificationOptionsList");
            arrayList2 = null;
        }
        this.C0 = arrayList2.contains("whatsapp");
        ArrayList<String> arrayList3 = this.Q0;
        if (arrayList3 == null) {
            kotlin.jvm.internal.o.C("verificationOptionsList");
        } else {
            arrayList = arrayList3;
        }
        boolean contains = arrayList.contains("verify_via_call");
        this.D0 = contains;
        ObservableBoolean observableBoolean = this.H0;
        if (!this.B0 && !this.C0 && !contains) {
            z = false;
        } else {
            z = true;
        }
        observableBoolean.h(z);
    }

    private final void M8() {
        String str = this.u;
        if (str != null) {
            kotlinx.coroutines.i.d(l0.a(this), null, null, new OTPFragmentViewModel$initiateCallVerification$1$1(this, str, null), 3, null);
        }
    }

    private final boolean M9() {
        Bundle B6 = B6();
        if (B6 == null) {
            return false;
        }
        return B6.getBoolean("skipSmsTrigger", false);
    }

    private final boolean P8() {
        return kotlin.jvm.internal.o.f(t8().H("enable_new_nu_du_flow", TejasConstants.ENABLE_V4_PROFILE_API_DEFAULT), "true");
    }

    public final void P9(String str) {
        this.V.r(new in.swiggy.android.commons.utils.l<>(new c.j0(str, 0)));
    }

    public final void Q9() {
        this.J0.h(false);
        this.K0.h(false);
    }

    public final void R9() {
        if (this.N0.g()) {
            Y9();
            return;
        }
        this.J0.h(true);
        this.K0.h(true);
    }

    private final void S8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(new c.f(this.u, this.w, this.v)));
    }

    public final void S9() {
        x.b(Z0, "smsVerificationTimerExpired: Timer expired after 5 secs or not?");
        if (!this.U) {
            G8();
        }
    }

    private final void T8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(new c.g(T7(), true)));
    }

    private final void T9(String str) {
        a8().d("otp-verify", str);
    }

    private final void U8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(new c.j(false)));
    }

    private final void V9() {
        io.reactivex.d<Long> L = io.reactivex.d.L(30000L, TimeUnit.SECONDS, io.reactivex.schedulers.a.c());
        final Function1<Long, Unit> function1 = new Function1<Long, Unit>() {
            {
                super(1);
            }

            @Override
            public Unit invoke(Long l) {
                invoke2(l);
                return Unit.a;
            }

            public final void invoke2(Long l) {
                OTPFragmentViewModel.this.S9();
            }
        };
        io.reactivex.functions.d<? super Long> dVar = new io.reactivex.functions.d() {
            @Override
            public final void accept(Object obj) {
                OTPFragmentViewModel.W9(Function1.this, obj);
            }
        };
        final OTPFragmentViewModel$startSMSVerificationTimer$2 oTPFragmentViewModel$startSMSVerificationTimer$2 = new Function1<Throwable, Unit>() {
            @Override
            public Unit invoke(Throwable th) {
                invoke2(th);
                return Unit.a;
            }

            public final void invoke2(Throwable th) {
                x.i(OTPFragmentViewModel.Z0, th);
            }
        };
        io.reactivex.disposables.b g0 = L.g0(dVar, new io.reactivex.functions.d() {
            @Override
            public final void accept(Object obj) {
                OTPFragmentViewModel.X9(Function1.this, obj);
            }
        });
        this.T = g0;
        if (g0 != null) {
            this.S.c(g0);
        }
    }

    public static final void W9(Function1 tmp0, Object obj) {
        kotlin.jvm.internal.o.k(tmp0, "$tmp0");
        tmp0.invoke(obj);
    }

    private final void X8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(new c.x(this.u, this.w, this.v)));
    }

    public static final void X9(Function1 tmp0, Object obj) {
        kotlin.jvm.internal.o.k(tmp0, "$tmp0");
        tmp0.invoke(obj);
    }

    private final void Y9() {
        this.X.o(Boolean.FALSE);
        r9();
    }

    public static void Z8(OTPFragmentViewModel oTPFragmentViewModel, Integer num, String str, String str2, String str3, String str4, int i, Object obj) {
        if (obj == null) {
            if ((i & 8) != 0) {
                str3 = "";
            }
            oTPFragmentViewModel.Y8(num, str, str2, str3, str4);
            return;
        }
        throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: logErrorImpression");
    }

    private final void a9(String str) {
        in.swiggy.android.analytics.gtm.g h = Y7().h("otp-verify", str, "-", 9999);
        kotlin.jvm.internal.o.j(h, "getGtmEventData(...)");
        Y7().b(h);
    }

    public final void aa(String str) {
        L9(false);
        this.K.h(str);
    }

    private final void b9(String str) {
        in.swiggy.android.analytics.gtm.g h = Y7().h("otp-verify", str, "-", 9999);
        kotlin.jvm.internal.o.j(h, "getGtmEventData(...)");
        Y7().j(h);
    }

    private final void c9() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(c.y.a));
    }

    private final void ca(String str, String str2) {
        T9("otp-verify-nux");
        I7(str, O7(), "otp-verify-nux", str2);
    }

    private final String d8(String str) {
        String group;
        if (str == null) {
            return "";
        }
        Matcher matcher = in.swiggy.android.repositories.saveablecontexts.i.U.matcher(str);
        if (!matcher.find() || (group = matcher.group(0)) == null) {
            return "";
        }
        return group;
    }

    private final void d9(final SwiggyApiResponse<UserResponseData> swiggyApiResponse) {
        String str;
        this.O0 = swiggyApiResponse.getData();
        Function1<ArrayList<Address>, Unit> function1 = new Function1<ArrayList<Address>, Unit>() {
            {
                super(1);
            }

            public final void a(ArrayList<Address> it) {
                kotlin.jvm.internal.o.k(it, "it");
                OTPFragmentViewModel.this.Z7().m0(it);
            }

            @Override
            public Unit invoke(ArrayList<Address> arrayList) {
                a(arrayList);
                return Unit.a;
            }
        };
        Function0<Unit> function0 = new Function0<Unit>() {
            {
                super(0);
            }

            @Override
            public Unit invoke() {
                invoke2();
                return Unit.a;
            }

            public final void invoke2() {
                if (swiggyApiResponse.getData() != null) {
                    OTPFragmentViewModel oTPFragmentViewModel = this;
                    oTPFragmentViewModel.u8().o(new in.swiggy.android.commons.utils.l<>(new c.b0(swiggyApiResponse, oTPFragmentViewModel.Z7(), oTPFragmentViewModel.h8(), oTPFragmentViewModel.r8(), oTPFragmentViewModel.q8(), false, oTPFragmentViewModel.N8())));
                }
            }
        };
        UserResponseData data = swiggyApiResponse.getData();
        if (data != null) {
            str = data.mCustomerId;
        } else {
            str = null;
        }
        if (str != null) {
            final kotlinx.coroutines.flow.d<Response<SwiggyApiResponse<AllAddress>>> invoke = this.k.invoke(str);
            final kotlinx.coroutines.flow.d<Response<? extends SwiggyApiResponse<AllAddress>>> dVar = new kotlinx.coroutines.flow.d<Response<? extends SwiggyApiResponse<AllAddress>>>() {

                public static final class AnonymousClass2<T> implements kotlinx.coroutines.flow.e {
                    final kotlinx.coroutines.flow.e a;

                    @kotlin.coroutines.jvm.internal.d(c = "in.swiggy.android.onboarding.viewmodel.OTPFragmentViewModel$onAuthenticationSuccess$$inlined$filter$1$2", f = "OTPFragmentViewModel.kt", l = {223}, m = "emit")
                    public static final class AnonymousClass1 extends ContinuationImpl {
                        Object a;
                        int b;

                        public AnonymousClass1(kotlin.coroutines.c cVar) {
                            super(cVar);
                        }

                        @Override
                        public final Object invokeSuspend(Object obj) {
                            this.a = obj;
                            this.b |= Integer.MIN_VALUE;
                            return AnonymousClass2.this.emit(null, this);
                        }
                    }

                    public AnonymousClass2(kotlinx.coroutines.flow.e eVar) {
                        this.a = eVar;
                    }

                    @Override
                    public final Object emit(Object obj, kotlin.coroutines.c cVar) {
                        AnonymousClass1 anonymousClass1;
                        Object f;
                        int i;
                        if (cVar instanceof AnonymousClass1) {
                            anonymousClass1 = (AnonymousClass1) cVar;
                            int i2 = anonymousClass1.b;
                            if ((i2 & Integer.MIN_VALUE) != 0) {
                                anonymousClass1.b = i2 - Integer.MIN_VALUE;
                                Object obj2 = anonymousClass1.a;
                                f = kotlin.coroutines.intrinsics.b.f();
                                i = anonymousClass1.b;
                                if (i == 0) {
                                    if (i == 1) {
                                        kotlin.n.b(obj2);
                                    } else {
                                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                                    }
                                } else {
                                    kotlin.n.b(obj2);
                                    kotlinx.coroutines.flow.e eVar = this.a;
                                    if (((Response) obj) instanceof Response.Success) {
                                        anonymousClass1.b = 1;
                                        if (eVar.emit(obj, anonymousClass1) == f) {
                                            return f;
                                        }
                                    }
                                }
                                return Unit.a;
                            }
                        }
                        anonymousClass1 = new AnonymousClass1(cVar);
                        Object obj22 = anonymousClass1.a;
                        f = kotlin.coroutines.intrinsics.b.f();
                        i = anonymousClass1.b;
                        if (i == 0) {
                        }
                        return Unit.a;
                    }
                }

                @Override
                public Object collect(kotlinx.coroutines.flow.e<? super Response<? extends SwiggyApiResponse<AllAddress>>> eVar, kotlin.coroutines.c cVar) {
                    Object f2;
                    Object collect = kotlinx.coroutines.flow.d.this.collect(new AnonymousClass2(eVar), cVar);
                    f2 = kotlin.coroutines.intrinsics.b.f();
                    if (collect == f2) {
                        return collect;
                    }
                    return Unit.a;
                }
            };
            LoginAddressSyncKt.b(new kotlinx.coroutines.flow.d<AllAddress>() {

                public static final class AnonymousClass2<T> implements kotlinx.coroutines.flow.e {
                    final kotlinx.coroutines.flow.e a;

                    @kotlin.coroutines.jvm.internal.d(c = "in.swiggy.android.onboarding.viewmodel.OTPFragmentViewModel$onAuthenticationSuccess$$inlined$map$1$2", f = "OTPFragmentViewModel.kt", l = {223}, m = "emit")
                    public static final class AnonymousClass1 extends ContinuationImpl {
                        Object a;
                        int b;

                        public AnonymousClass1(kotlin.coroutines.c cVar) {
                            super(cVar);
                        }

                        @Override
                        public final Object invokeSuspend(Object obj) {
                            this.a = obj;
                            this.b |= Integer.MIN_VALUE;
                            return AnonymousClass2.this.emit(null, this);
                        }
                    }

                    public AnonymousClass2(kotlinx.coroutines.flow.e eVar) {
                        this.a = eVar;
                    }

                    @Override
                    public final Object emit(Object obj, kotlin.coroutines.c cVar) {
                        AnonymousClass1 anonymousClass1;
                        Object f;
                        int i;
                        Response.Success success;
                        AllAddress allAddress;
                        SwiggyApiResponse swiggyApiResponse;
                        if (cVar instanceof AnonymousClass1) {
                            anonymousClass1 = (AnonymousClass1) cVar;
                            int i2 = anonymousClass1.b;
                            if ((i2 & Integer.MIN_VALUE) != 0) {
                                anonymousClass1.b = i2 - Integer.MIN_VALUE;
                                Object obj2 = anonymousClass1.a;
                                f = kotlin.coroutines.intrinsics.b.f();
                                i = anonymousClass1.b;
                                if (i == 0) {
                                    if (i == 1) {
                                        kotlin.n.b(obj2);
                                    } else {
                                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                                    }
                                } else {
                                    kotlin.n.b(obj2);
                                    kotlinx.coroutines.flow.e eVar = this.a;
                                    Response response = (Response) obj;
                                    if (response instanceof Response.Success) {
                                        success = (Response.Success) response;
                                    } else {
                                        success = null;
                                    }
                                    if (success == null || (swiggyApiResponse = (SwiggyApiResponse) success.getResponse()) == null || (allAddress = (AllAddress) swiggyApiResponse.getData()) == null) {
                                        allAddress = new AllAddress(null, 1, null);
                                    }
                                    anonymousClass1.b = 1;
                                    if (eVar.emit(allAddress, anonymousClass1) == f) {
                                        return f;
                                    }
                                }
                                return Unit.a;
                            }
                        }
                        anonymousClass1 = new AnonymousClass1(cVar);
                        Object obj22 = anonymousClass1.a;
                        f = kotlin.coroutines.intrinsics.b.f();
                        i = anonymousClass1.b;
                        if (i == 0) {
                        }
                        return Unit.a;
                    }
                }

                @Override
                public Object collect(kotlinx.coroutines.flow.e<? super AllAddress> eVar, kotlin.coroutines.c cVar) {
                    Object f2;
                    Object collect = kotlinx.coroutines.flow.d.this.collect(new AnonymousClass2(eVar), cVar);
                    f2 = kotlin.coroutines.intrinsics.b.f();
                    if (collect == f2) {
                        return collect;
                    }
                    return Unit.a;
                }
            }, function0, function1, 0L, 0L, 12, null);
            return;
        }
        function0.invoke();
    }

    public final String f8(String str, boolean z) {
        if (z) {
            return str + "-reverification";
        }
        return str;
    }

    public static void g9(OTPFragmentViewModel oTPFragmentViewModel, Integer num, String str, boolean z, int i, Object obj) {
        if (obj == null) {
            if ((i & 4) != 0) {
                z = true;
            }
            oTPFragmentViewModel.f9(num, str, z);
            return;
        }
        throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: onOTPVerificationFailure");
    }

    public static void j9(OTPFragmentViewModel oTPFragmentViewModel, String str, boolean z, int i, Object obj) {
        if (obj == null) {
            if ((i & 2) != 0) {
                z = true;
            }
            oTPFragmentViewModel.i9(str, z);
            return;
        }
        throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: onRetryVerificationFailure");
    }

    public final void m9(String str) {
        in.swiggy.android.commons.extension.a.b(X7(), "IS_OTP_AUTO_READ", Boolean.valueOf(kotlin.jvm.internal.o.f(str, "Sms-automatic")));
        n9(g8(), str);
    }

    private final void o9() {
        q1 d2;
        q1 q1Var = this.A0;
        if (q1Var != null && q1Var.b()) {
            return;
        }
        d2 = kotlinx.coroutines.i.d(l0.a(this), v0.b(), null, new OTPFragmentViewModel$pollCallVerificationStatus$1(new c(f0.v0), this, null), 2, null);
        this.A0 = d2;
    }

    public final void p9(String str) {
        F9(str);
        this.U0 = "Whatsapp";
        m9("Whatsapp");
    }

    public final void r9() {
        B9(false);
        this.K0.h(false);
        this.J0.h(false);
    }

    private final void s9() {
        D9(false);
        F9("");
        L9(false);
        H9(false);
    }

    private final void t9(String str, String str2) {
        if (this.x) {
            v9(str, str2);
            return;
        }
        this.V.r(new in.swiggy.android.commons.utils.l<>(new c.i0(new OTPFragmentViewModel$sendOtp$1(this), new OTPFragmentViewModel$sendOtp$2(this))));
        if (!M9()) {
            u9(str, str2);
            return;
        }
        U9(r0().getString(R.string.otp_has_been_sent_by_sms) + " \n" + r0().getString(R.string.retry_countdown_timer_text), r0().getString(R.string.otp_has_been_sent_by_sms) + " \n" + r0().getString(R.string.retry_via_text));
    }

    private final void u9(String str, String str2) {
        String str3 = this.u;
        if (str3 != null) {
            kotlinx.coroutines.i.d(l0.a(this), null, null, new OTPFragmentViewModel$sendSmsOtp$1$1(this, str3, str, str2, null), 3, null);
        }
    }

    private final void v8(SwiggyBaseResponse swiggyBaseResponse) {
        String str;
        Integer statusCode;
        if (swiggyBaseResponse != null) {
            str = swiggyBaseResponse.getStatusMessage();
        } else {
            str = null;
        }
        if (swiggyBaseResponse != null && (statusCode = swiggyBaseResponse.getStatusCode()) != null) {
            int intValue = statusCode.intValue();
            if (intValue != 1) {
                if (intValue != 21) {
                    if (intValue != 22) {
                        switch (intValue) {
                            case 10:
                            case 11:
                            case 12:
                                G7();
                                Y8(Integer.valueOf(intValue), swiggyBaseResponse.getStatusMessage(), r0().getString(R.string.verification_via_call_failed), "call", "verify");
                                if (str == null) {
                                    str = r0().getString(R.string.verification_via_call_failed);
                                }
                                j9(this, str, false, 2, null);
                                q1 q1Var = this.A0;
                                if (q1Var != null) {
                                    q1.a.a(q1Var, null, 1, null);
                                }
                                x8(intValue);
                                return;
                            default:
                                return;
                        }
                    }
                    G7();
                    Y8(Integer.valueOf(intValue), swiggyBaseResponse.getStatusMessage(), r0().getString(R.string.call_verification_wrong_key_pressed), "call", "verify");
                    j9(this, r0().getString(R.string.call_verification_wrong_key_pressed), false, 2, null);
                    q1 q1Var2 = this.A0;
                    if (q1Var2 != null) {
                        q1.a.a(q1Var2, null, 1, null);
                        return;
                    }
                    return;
                }
                x.b(Z0, "handleCallVerificationStatusFailureResponse: Verification Status Pending");
                return;
            }
            G7();
            Y8(Integer.valueOf(intValue), swiggyBaseResponse.getStatusMessage(), r0().getString(R.string.verification_via_call_failed), "call", "verify");
            if (str == null) {
                str = r0().getString(R.string.verification_via_call_failed);
            }
            j9(this, str, false, 2, null);
            q1 q1Var3 = this.A0;
            if (q1Var3 != null) {
                q1.a.a(q1Var3, null, 1, null);
            }
        }
    }

    private final void v9(String str, String str2) {
        String str3 = this.u;
        if (str3 != null) {
            kotlinx.coroutines.i.d(l0.a(this), null, null, new OTPFragmentViewModel$sendWhatsappOtp$1$1(this, str3, str, str2, null), 3, null);
        }
    }

    private final void w8(SwiggyApiResponse<UserResponseData> swiggyApiResponse) {
        G7();
        q1 q1Var = this.A0;
        if (q1Var != null) {
            q1.a.a(q1Var, null, 1, null);
        }
        if (swiggyApiResponse.getData() != null) {
            d9(swiggyApiResponse);
            return;
        }
        Y8(swiggyApiResponse.getStatusCode(), swiggyApiResponse.getStatusMessage(), r0().getString(R.string.verification_via_whatsapp_failed), "call", "verify");
        j9(this, r0().getString(R.string.verification_via_call_failed), false, 2, null);
    }

    public final void w9() {
        String str;
        String J;
        String g = this.H.g();
        if (g == null) {
            return;
        }
        String string = r0().getString(R.string.otp_content_description);
        String str2 = "";
        if (string == null) {
            str = "";
        } else {
            str = string;
        }
        String string2 = r0().getString(R.string.otp_capital);
        if (string2 != null) {
            str2 = string2;
        }
        ObservableField<String> observableField = this.I;
        J = kotlin.text.q.J(g, str2, str, false, 4, null);
        observableField.h(J);
    }

    public final void x8(int i) {
        Z7().E(i);
        this.V.o(new in.swiggy.android.commons.utils.l<>(c.a0.a));
    }

    private final void y9() {
        String str;
        String J;
        int i;
        boolean z;
        ObservableField<String> observableField = this.A;
        in.swiggy.android.mvvm.services.s r0 = r0();
        Object[] objArr = new Object[1];
        String str2 = this.u;
        if (str2 != null && J != null) {
            int length = J.length() - 1;
            int i2 = 0;
            boolean z2 = false;
            while (i2 <= length) {
                if (!z2) {
                    i = i2;
                } else {
                    i = length;
                }
                if (kotlin.jvm.internal.o.m(J.charAt(i), 32) <= 0) {
                    z = true;
                } else {
                    z = false;
                }
                if (!z2) {
                    if (!z) {
                        z2 = true;
                    } else {
                        i2++;
                    }
                } else if (!z) {
                    break;
                } else {
                    length--;
                }
            }
            str = J.subSequence(i2, length + 1).toString();
        } else {
            str = null;
        }
        objArr[0] = str;
        observableField.h(r0.b(R.string.verify_otp_header_content_description, objArr));
    }

    public final void z8(SwiggyApiResponse<UserResponseData> swiggyApiResponse, String str) {
        I8();
        Integer statusCode = swiggyApiResponse.getStatusCode();
        if (statusCode != null && statusCode.intValue() == 0) {
            H8();
            K7(str, LoggingConstants.SUCCESS);
            d9(swiggyApiResponse);
        } else if (statusCode != null && statusCode.intValue() == 1) {
            String statusMessage = swiggyApiResponse.getStatusMessage();
            if (statusMessage != null) {
                Z8(this, swiggyApiResponse.getStatusCode(), statusMessage, statusMessage, null, "verify", 8, null);
                g9(this, 1, statusMessage, false, 4, null);
                K7(str, "failure-1");
            }
        } else {
            H8();
            String statusMessage2 = swiggyApiResponse.getStatusMessage();
            if (statusMessage2 != null) {
                P9(statusMessage2);
            }
            String statusMessage3 = swiggyApiResponse.getStatusMessage();
            K7(str, "failure-" + statusMessage3);
        }
    }

    public void A8() {
        L9(true);
        this.C.h(r0().getString(R.string.network_not_available_message));
    }

    public void A9(String otp) {
        boolean C;
        boolean C2;
        kotlin.jvm.internal.o.k(otp, "otp");
        Y9();
        F9(otp);
        C = kotlin.text.q.C(otp);
        boolean z = true;
        if (!(!C) || !R8()) {
            C2 = kotlin.text.q.C(otp);
            if ((!C2) && Q8()) {
                B9(false);
            }
        } else {
            D9(false);
            L9(false);
            H9(false);
        }
        ObservableField<Boolean> observableField = this.z;
        if (g8().length() != 6) {
            z = false;
        }
        observableField.h(Boolean.valueOf(z));
        if (this.J.b(otp)) {
            this.G.h(otp);
        }
    }

    public void C8(SwiggyBaseResponse response) {
        String str;
        CharSequence k1;
        kotlin.jvm.internal.o.k(response, "response");
        I8();
        p.a aVar = in.swiggy.android.network.interceptors.p.e;
        String tid = response.getTid();
        if (tid != null) {
            k1 = StringsKt__StringsKt.k1(tid);
            str = k1.toString();
        } else {
            str = null;
        }
        aVar.c(str, "https://profile.swiggy.comapi/v3/app/request_call_verification", Z7());
        o9();
        U9(r0().getString(R.string.call_verification_in_progress_message) + " \n" + r0().getString(R.string.retry_countdown_timer_text), r0().getString(R.string.call_not_received_question) + " \n" + r0().getString(R.string.retry_via_text));
    }

    public final void C9(boolean z) {
        this.P = z;
    }

    @Override
    public void E6(int i, int i2, Intent intent) {
        String str;
        super.E6(i, i2, intent);
        if (i == 2) {
            c9();
            Z7().g0();
        } else if (i == LoginLimitErrorActivity.E.g()) {
            if (i2 == -1) {
                V8();
            } else {
                W8();
            }
        } else if (i == 150) {
            if (i2 == -1) {
                if (intent != null) {
                    str = intent.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE);
                } else {
                    str = null;
                }
                String d8 = d8(str);
                if (this.J.b(d8)) {
                    Z7().Z(d8);
                    this.P = true;
                    F9(d8);
                    m9("Sms-consent");
                }
                in.swiggy.android.analytics.gtm.g h = Y7().h("otp-verify", "click-user-consent-request", "allowed", 9999);
                kotlin.jvm.internal.o.j(h, "getGtmEventData(...)");
                Y7().b(h);
                return;
            }
            in.swiggy.android.analytics.gtm.g h2 = Y7().h("otp-verify", "click-user-consent-request", "denied", 9999);
            kotlin.jvm.internal.o.j(h2, "getGtmEventData(...)");
            Y7().b(h2);
        }
    }

    public final void E7(int i) {
        if (kotlin.jvm.internal.o.f(this.L.g(), Boolean.TRUE)) {
            if (i % this.R == 0 || this.Q) {
                G().d(ForgotPasswordOTPViewModel.class, r0().b(R.string.enter_otp_within, Integer.valueOf(i)));
            }
            if (this.Q) {
                this.Q = false;
            }
        }
    }

    public final void E9(boolean z) {
        this.x = z;
    }

    public final void F7() {
        this.V.r(new in.swiggy.android.commons.utils.l<>(c.z.a));
    }

    public final in.swiggy.android.commons.utils.contextservice.h G() {
        in.swiggy.android.commons.utils.contextservice.h hVar = this.n;
        if (hVar != null) {
            return hVar;
        }
        kotlin.jvm.internal.o.C("contextService");
        return null;
    }

    public void G7() {
        CountDownTimer countDownTimer = this.O;
        if (countDownTimer != null) {
            countDownTimer.cancel();
        }
        this.K.h("");
        J7();
    }

    public final void G9(String str) {
        this.u = str;
    }

    public final void I7(String otp, CloningSignalsProto.CloningSignals cloningSignals, String traceName, String otpSource) {
        kotlin.jvm.internal.o.k(otp, "otp");
        kotlin.jvm.internal.o.k(cloningSignals, "cloningSignals");
        kotlin.jvm.internal.o.k(traceName, "traceName");
        kotlin.jvm.internal.o.k(otpSource, "otpSource");
        kotlinx.coroutines.i.d(l0.a(this), null, null, new OTPFragmentViewModel$doSignIn$1(this, cloningSignals, otp, otpSource, traceName, null), 3, null);
    }

    public void I8() {
        this.W0.h(false);
    }

    @Override
    public void J6() {
        super.J6();
        G7();
        q1 q1Var = this.A0;
        if (q1Var != null) {
            q1.a.a(q1Var, null, 1, null);
        }
        Z9();
    }

    public final void J7() {
        if (this.E0.g()) {
            this.Z.h(true);
            b9("impression-resend-sms");
        }
        if (this.G0.g()) {
            this.c0.h(true);
            b9("impression-verify-via-call");
        }
        if (this.F0.g()) {
            this.p0.h(true);
            b9("impression-verify-via-whatsapp");
        }
    }

    public final void J9(String str) {
        this.v = str;
    }

    public final void K9(String str) {
        this.w = str;
    }

    public final void L9(boolean z) {
        this.y0.h(z);
        if (KotlinExtensionsKt.h(Boolean.valueOf(z))) {
            r9();
        }
    }

    public final ObservableBoolean M7() {
        return this.I0;
    }

    public final ObservableBoolean N7() {
        return this.M0;
    }

    public final boolean N8() {
        return this.P0;
    }

    public void N9(Loader loader) {
        kotlin.jvm.internal.o.k(loader, "loader");
        this.W0.h(true);
    }

    public final CloningSignalsProto.CloningSignals O7() {
        Context applicationContext = this.j.getApplicationContext();
        kotlin.jvm.internal.o.j(applicationContext, "getApplicationContext(...)");
        return in.swiggy.android.feature.fraudDetection.c.a(applicationContext);
    }

    public final ObservableBoolean O8() {
        return this.W0;
    }

    public final void O9() {
        boolean z;
        this.E0.h(this.B0);
        this.F0.h(this.C0);
        this.G0.h(this.D0);
        ObservableBoolean observableBoolean = this.I0;
        if (!this.E0.g() && !this.F0.g() && !this.G0.g()) {
            z = false;
        } else {
            z = true;
        }
        observableBoolean.h(z);
        Y9();
    }

    public CountDownTimer P7(long j, String showCallVerificationStatus, String afterTimerText) {
        kotlin.jvm.internal.o.k(showCallVerificationStatus, "showCallVerificationStatus");
        kotlin.jvm.internal.o.k(afterTimerText, "afterTimerText");
        return new b(showCallVerificationStatus, afterTimerText, j * 1000);
    }

    public final ObservableBoolean Q7() {
        return this.c0;
    }

    public final boolean Q8() {
        return ((Boolean) this.S0.getValue()).booleanValue();
    }

    public final ObservableBoolean R7() {
        return this.Z;
    }

    public final boolean R8() {
        return ((Boolean) this.R0.getValue()).booleanValue();
    }

    public final ObservableBoolean S7() {
        return this.p0;
    }

    public String T7() {
        return "OTPFragment";
    }

    @Override
    public void U6() {
        Y7().m("otp-verify");
    }

    public final ObservableBoolean U7() {
        return this.N0;
    }

    public final void U9(String showCallVerificationStatus, String afterTimerText) {
        kotlin.jvm.internal.o.k(showCallVerificationStatus, "showCallVerificationStatus");
        kotlin.jvm.internal.o.k(afterTimerText, "afterTimerText");
        H7();
        this.M.h(1);
        CountDownTimer P7 = P7(25L, showCallVerificationStatus, afterTimerText);
        this.O = P7;
        if (P7 != null) {
            P7.start();
        }
    }

    public final PublishProcessor<Integer> V7() {
        PublishProcessor<Integer> publishProcessor = this.t;
        if (publishProcessor != null) {
            return publishProcessor;
        }
        kotlin.jvm.internal.o.C("limitErrorProcessor");
        return null;
    }

    public final void V8() {
        boolean C;
        UserResponseData userResponseData = this.O0;
        if (userResponseData != null) {
            String str = userResponseData.mCustomerId;
            if (str != null) {
                C = kotlin.text.q.C(str);
                if (!C) {
                    if (P8()) {
                        T8();
                        return;
                    } else {
                        U8();
                        return;
                    }
                }
            }
            if (in.swiggy.android.loginsignup.l.c(e3())) {
                X8();
            } else {
                S8();
            }
        }
    }

    public final LiveData<in.swiggy.android.commons.utils.l<in.swiggy.android.onboarding.c>> W7() {
        return this.W;
    }

    public void W8() {
        this.V.o(new in.swiggy.android.commons.utils.l<>(c.s.a));
    }

    public final SharedPreferences X7() {
        SharedPreferences sharedPreferences = this.m;
        if (sharedPreferences != null) {
            return sharedPreferences;
        }
        kotlin.jvm.internal.o.C("mSharedPreferences");
        return null;
    }

    public final in.swiggy.android.analytics.interfaces.c Y7() {
        in.swiggy.android.analytics.interfaces.c cVar = this.p;
        if (cVar != null) {
            return cVar;
        }
        kotlin.jvm.internal.o.C("mSwiggyEventHandler");
        return null;
    }

    public void Y8(Integer num, String str, String str2, String verificationMode, String endPoint) {
        String str3;
        kotlin.jvm.internal.o.k(verificationMode, "verificationMode");
        kotlin.jvm.internal.o.k(endPoint, "endPoint");
        JSONObject jSONObject = new JSONObject();
        if (num != null) {
            str3 = String.valueOf(num);
        } else {
            str3 = "";
        }
        jSONObject.putOpt("error-code", str3);
        jSONObject.putOpt("backend-error", str);
        jSONObject.putOpt("user-error", str2);
        jSONObject.putOpt(AppsFlyerProperties.CHANNEL, verificationMode);
        jSONObject.putOpt("end-point", endPoint);
        Y7().j(Y7().r("otp-verify", "impression-error-msg", "-", "-", in.swiggy.android.logging.utils.a.a(jSONObject)));
    }

    public final in.swiggy.android.repositories.interfaces.d Z7() {
        in.swiggy.android.repositories.interfaces.d dVar = this.r;
        if (dVar != null) {
            return dVar;
        }
        kotlin.jvm.internal.o.C("mUser");
        return null;
    }

    public final void Z9() {
        io.reactivex.disposables.b bVar = this.T;
        if (bVar != null) {
            bVar.dispose();
        }
    }

    public final in.swiggy.android.analytics.newrelic.a a8() {
        in.swiggy.android.analytics.newrelic.a aVar = this.q;
        if (aVar != null) {
            return aVar;
        }
        kotlin.jvm.internal.o.C("newrelicPerformanceUtils");
        return null;
    }

    public String b8(Integer num) {
        int i;
        in.swiggy.android.mvvm.services.s r0 = r0();
        if (num != null && num.intValue() == 9) {
            i = R.string.verification_limit_exceeded_try_later;
        } else if (num != null && num.intValue() == 400) {
            i = R.string.invalid_mobile_number;
        } else {
            i = R.string.something_went_wrong_try_again_later;
        }
        return r0.getString(i);
    }

    public final void ba() {
        this.U = false;
        V9();
    }

    public final in.swiggy.android.commons.validation.f<String> c8() {
        return this.J;
    }

    public final in.swiggy.android.repositories.interfaces.e e3() {
        in.swiggy.android.repositories.interfaces.e eVar = this.s;
        if (eVar != null) {
            return eVar;
        }
        kotlin.jvm.internal.o.C("xpExperimentContext");
        return null;
    }

    public final boolean e8() {
        return this.P;
    }

    public void e9() {
        this.L0 = true;
        s9();
        a9("click-verify-via-call");
        H7();
        M8();
    }

    public void f9(Integer num, String errorMessage, boolean z) {
        String str;
        String J;
        kotlin.jvm.internal.o.k(errorMessage, "errorMessage");
        this.z.h(Boolean.FALSE);
        L9(true);
        if (z) {
            if (!this.I0.g()) {
                O9();
            }
            J7();
            this.K.h(r0().getString(R.string.retry_via_text));
        } else {
            J8();
            this.K.h("");
        }
        ObservableField<String> observableField = this.C;
        if (this.I0.g()) {
            str = String.valueOf(errorMessage);
        } else {
            str = errorMessage;
        }
        observableField.h(str);
        ObservableField<String> observableField2 = this.D;
        String lowerCase = errorMessage.toLowerCase();
        kotlin.jvm.internal.o.j(lowerCase, "toLowerCase(...)");
        J = kotlin.text.q.J(lowerCase, r0().getString(R.string.otp_smallcase), r0().getString(R.string.otp_content_description), false, 4, null);
        observableField2.h(J);
        D9(true);
    }

    public final String g8() {
        return (String) this.T0.getValue();
    }

    public final String h8() {
        return this.u;
    }

    public final Function0<Unit> h9() {
        return new Function0<Unit>() {
            {
                super(0);
            }

            @Override
            public Unit invoke() {
                invoke2();
                return Unit.a;
            }

            public final void invoke2() {
                if (!KotlinExtensionsKt.h(OTPFragmentViewModel.this.z.g()) || OTPFragmentViewModel.this.N7().g()) {
                    return;
                }
                OTPFragmentViewModel.this.m9("Sms-manual");
            }
        };
    }

    public final boolean i8() {
        return this.L0;
    }

    public void i9(String errorMessage, boolean z) {
        boolean C;
        kotlin.jvm.internal.o.k(errorMessage, "errorMessage");
        this.z.h(Boolean.FALSE);
        H9(true);
        if (z) {
            if (!this.I0.g()) {
                O9();
            }
            J7();
            this.K.h(r0().getString(R.string.retry_via_text));
        } else {
            J8();
            this.K.h("");
        }
        this.E.h(errorMessage);
        this.F.h(errorMessage);
        C = kotlin.text.q.C(g8());
        if (!C) {
            D9(true);
        }
    }

    @Override
    public void init() {
        L8();
        this.J.c(new in.swiggy.android.commons.validation.d(r0().getString(R.string.enter_otp)));
        if (this.u != null) {
            y9();
            this.B.h(this.u);
            String string = r0().getString(R.string.didnt_receive_it);
            String string2 = r0().getString(R.string.retry_countdown_timer_text);
            t9(string + " " + string2, r0().getString(R.string.retry_via_text));
        } else {
            P9(r0().getString(R.string.something_went_wrong_try_again));
        }
        I9();
        B7();
        io.reactivex.disposables.a aVar = this.S;
        PublishProcessor<Integer> V7 = V7();
        final Function1<Integer, Unit> function1 = new Function1<Integer, Unit>() {
            {
                super(1);
            }

            public final void a(Integer num) {
                if (num != null && num.intValue() == 1) {
                    OTPFragmentViewModel.this.V8();
                } else if ((num != null && num.intValue() == -1) || ((num != null && num.intValue() == 2) || (num != null && num.intValue() == 3))) {
                    OTPFragmentViewModel.this.W8();
                }
            }

            @Override
            public Unit invoke(Integer num) {
                a(num);
                return Unit.a;
            }
        };
        aVar.c(V7.f0(new io.reactivex.functions.d() {
            @Override
            public final void accept(Object obj) {
                OTPFragmentViewModel.K8(Function1.this, obj);
            }
        }));
    }

    public final ObservableBoolean j8() {
        return this.J0;
    }

    public final ObservableBoolean k8() {
        return this.K0;
    }

    public void k9() {
        this.L0 = true;
        s9();
        this.U0 = "Sms-manual";
        a9("click-resend-sms");
        H7();
        N9(Loader.SmsRetry);
        u9(r0().getString(R.string.otp_has_been_sent_by_sms) + " \n" + r0().getString(R.string.retry_countdown_timer_text), r0().getString(R.string.otp_has_been_sent_by_sms) + " \n" + r0().getString(R.string.retry_via_text));
    }

    public final ObservableBoolean l8() {
        return this.G0;
    }

    public final void l9() {
        this.L0 = true;
        s9();
        this.U0 = "Whatsapp";
        a9("click-verify-via-whatsapp");
        H7();
        N9(Loader.WhatsApp);
        v9(r0().getString(R.string.otp_sent_via_whatsapp) + " \n" + r0().getString(R.string.retry_countdown_timer_text), r0().getString(R.string.otp_sent_via_whatsapp) + " \n" + r0().getString(R.string.retry_via_text));
    }

    public final ObservableBoolean m8() {
        return this.E0;
    }

    public final ObservableBoolean n8() {
        return this.F0;
    }

    public final void n9(String str, String otpSource) {
        kotlin.jvm.internal.o.k(otpSource, "otpSource");
        if (str == null) {
            return;
        }
        F9(str);
        this.z.h(Boolean.FALSE);
        if (this.J.b(str)) {
            ca(str, otpSource);
        } else {
            P9("OTP cannot be left blank");
        }
        G7();
        in.swiggy.android.analytics.gtm.g h = Y7().h("otp-verify", "click-verify-otp", "-", 9999);
        kotlin.jvm.internal.o.j(h, "getGtmEventData(...)");
        Y7().b(h);
    }

    public final float o8(int i, int i2) {
        return in.swiggy.android.utils.f.e(((i - (in.swiggy.android.utils.f.b(12, G()) * (i2 - 1))) - in.swiggy.android.utils.f.b(32, G())) / i2, G());
    }

    @Override
    public void onCleared() {
        super.onCleared();
        GeneralExtensionsKt.c(this.S);
    }

    public final LiveData<Boolean> p8() {
        return this.Y;
    }

    public final String q8() {
        return this.v;
    }

    public final void q9(String smsMessage) {
        kotlin.jvm.internal.o.k(smsMessage, "smsMessage");
        String d8 = d8(smsMessage);
        if (this.J.b(d8)) {
            Z7().Z(d8);
            this.P = true;
            this.K0.h(false);
            B9(true);
            F9(d8);
            kotlinx.coroutines.i.d(l0.a(this), DispatchProviderKt.c().Q(DispatchProviderKt.b().n1()), null, new OTPFragmentViewModel$readOtpFromSms$$inlined$delayOnIoThread$1(TimeUnit.MILLISECONDS, 1000L, null, this), 2, null);
        }
    }

    public final in.swiggy.android.mvvm.services.s r0() {
        in.swiggy.android.mvvm.services.s sVar = this.l;
        if (sVar != null) {
            return sVar;
        }
        kotlin.jvm.internal.o.C("resourcesService");
        return null;
    }

    public final String r8() {
        return this.w;
    }

    public final in.swiggy.android.dls.button.a s8() {
        return (in.swiggy.android.dls.button.a) this.V0.getValue();
    }

    public final in.swiggy.android.repositories.interfaces.e t8() {
        in.swiggy.android.repositories.interfaces.e eVar = this.N;
        if (eVar != null) {
            return eVar;
        }
        kotlin.jvm.internal.o.C("xExperimentContext");
        return null;
    }

    public final y<in.swiggy.android.commons.utils.l<in.swiggy.android.onboarding.c>> u8() {
        return this.V;
    }

    public final void x9(String str) {
        this.y = str;
    }

    public void y8(Integer num, String displayMessage, String str, String verificationMode) {
        kotlin.jvm.internal.o.k(displayMessage, "displayMessage");
        kotlin.jvm.internal.o.k(verificationMode, "verificationMode");
        Y8(num, str, displayMessage, verificationMode, "send");
        g9(this, num, displayMessage, false, 4, null);
        J7();
        x.e(Z0, str);
    }

    public final void z9(boolean z) {
        this.P0 = z;
    }
}