package com.revenuecat.purchases.ui.revenuecatui.components;

import E3.v;
import J4.c;
import com.revenuecat.purchases.paywalls.components.common.ComponentOverride;
import com.revenuecat.purchases.ui.revenuecatui.CustomVariableValue;
import com.revenuecat.purchases.ui.revenuecatui.composables.OfferEligibility;
import com.revenuecat.purchases.ui.revenuecatui.helpers.NonEmptyList;
import com.revenuecat.purchases.ui.revenuecatui.helpers.Result;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import kotlin.jvm.internal.o;
import l5.C;
import l5.n;
import m1.g;
import x4.AbstractC3250p;
import x4.AbstractC3253s;
import x4.z;

/* JADX INFO: loaded from: classes3.dex */
public final class PresentedPartialKt {

    public /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
        public static final /* synthetic */ int[] $EnumSwitchMapping$1;
        public static final /* synthetic */ int[] $EnumSwitchMapping$2;

        static {
            int[] iArr = new int[ComponentOverride.EqualityOperator.values().length];
            try {
                iArr[ComponentOverride.EqualityOperator.EQUALS.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[ComponentOverride.EqualityOperator.NOT_EQUALS.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            $EnumSwitchMapping$0 = iArr;
            int[] iArr2 = new int[ComponentOverride.ArrayOperator.values().length];
            try {
                iArr2[ComponentOverride.ArrayOperator.IN.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                iArr2[ComponentOverride.ArrayOperator.NOT_IN.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            $EnumSwitchMapping$1 = iArr2;
            int[] iArr3 = new int[ScreenCondition.values().length];
            try {
                iArr3[ScreenCondition.COMPACT.ordinal()] = 1;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                iArr3[ScreenCondition.MEDIUM.ordinal()] = 2;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                iArr3[ScreenCondition.EXPANDED.ordinal()] = 3;
            } catch (NoSuchFieldError unused7) {
            }
            $EnumSwitchMapping$2 = iArr3;
        }
    }

    public static final /* synthetic */ PresentedPartial buildPresentedPartial(List list, ScreenCondition windowSize, OfferEligibility offerEligibility, ComponentViewState state, ConditionContext conditionContext) {
        o.h(list, "<this>");
        o.h(windowSize, "windowSize");
        o.h(offerEligibility, "offerEligibility");
        o.h(state, "state");
        o.h(conditionContext, "conditionContext");
        Iterator it = list.iterator();
        PresentedPartial presentedPartialCombineOrReplace = null;
        while (it.hasNext()) {
            PresentedOverride presentedOverride = (PresentedOverride) it.next();
            if (shouldApply(presentedOverride, windowSize, offerEligibility, state, conditionContext)) {
                presentedPartialCombineOrReplace = combineOrReplace(presentedPartialCombineOrReplace, presentedOverride.getProperties());
            }
        }
        return presentedPartialCombineOrReplace;
    }

    public static /* synthetic */ PresentedPartial buildPresentedPartial$default(List list, ScreenCondition screenCondition, OfferEligibility offerEligibility, ComponentViewState componentViewState, ConditionContext conditionContext, int i6, Object obj) {
        if ((i6 & 8) != 0) {
            conditionContext = new ConditionContext(null, z.f26066a);
        }
        return buildPresentedPartial(list, screenCondition, offerEligibility, componentViewState, conditionContext);
    }

    private static final <T extends PresentedPartial<T>> T combineOrReplace(PresentedPartial<T> presentedPartial, T t6) {
        T t7;
        return (presentedPartial == null || (t7 = (T) presentedPartial.combine(t6)) == null) ? t6 : t7;
    }

    private static final boolean evaluate(ComponentOverride.Condition condition, ScreenCondition screenCondition, OfferEligibility offerEligibility, ComponentViewState componentViewState, ConditionContext conditionContext) {
        if (o.c(condition, ComponentOverride.Condition.Compact.INSTANCE) ? true : o.c(condition, ComponentOverride.Condition.Medium.INSTANCE) ? true : o.c(condition, ComponentOverride.Condition.Expanded.INSTANCE)) {
            return getApplicableConditions(screenCondition).contains(condition);
        }
        if (o.c(condition, ComponentOverride.Condition.MultiplePhaseOffers.INSTANCE)) {
            return offerEligibility.getHasMultipleDiscountedPhases();
        }
        if (o.c(condition, ComponentOverride.Condition.IntroOffer.INSTANCE)) {
            return offerEligibility.isIntroOffer();
        }
        if (condition instanceof ComponentOverride.Condition.IntroOfferRule) {
            return evaluate((ComponentOverride.Condition.IntroOfferRule) condition, offerEligibility);
        }
        if (o.c(condition, ComponentOverride.Condition.Selected.INSTANCE)) {
            return componentViewState == ComponentViewState.SELECTED;
        }
        if (o.c(condition, ComponentOverride.Condition.PromoOffer.INSTANCE)) {
            return offerEligibility.isPromoOffer();
        }
        if (condition instanceof ComponentOverride.Condition.PromoOfferRule) {
            return evaluate((ComponentOverride.Condition.PromoOfferRule) condition, offerEligibility);
        }
        if (condition instanceof ComponentOverride.Condition.SelectedPackage) {
            return evaluate((ComponentOverride.Condition.SelectedPackage) condition, conditionContext.getSelectedPackageId());
        }
        if (condition instanceof ComponentOverride.Condition.Variable) {
            return evaluate((ComponentOverride.Condition.Variable) condition, conditionContext.getCustomVariables());
        }
        if (o.c(condition, ComponentOverride.Condition.Unsupported.INSTANCE)) {
            return false;
        }
        throw new v();
    }

    private static final Set<ComponentOverride.Condition> getApplicableConditions(ScreenCondition screenCondition) {
        int i6 = WhenMappings.$EnumSwitchMapping$2[screenCondition.ordinal()];
        if (i6 == 1) {
            return g.o(ComponentOverride.Condition.Compact.INSTANCE);
        }
        if (i6 == 2) {
            return AbstractC3250p.Y(new ComponentOverride.Condition[]{ComponentOverride.Condition.Compact.INSTANCE, ComponentOverride.Condition.Medium.INSTANCE});
        }
        if (i6 == 3) {
            return AbstractC3250p.Y(new ComponentOverride.Condition[]{ComponentOverride.Condition.Compact.INSTANCE, ComponentOverride.Condition.Medium.INSTANCE, ComponentOverride.Condition.Expanded.INSTANCE});
        }
        throw new v();
    }

    private static final boolean matchesValue(ComponentOverride.Condition.Variable variable, CustomVariableValue customVariableValue) {
        if (variable.getValue().h()) {
            return (customVariableValue instanceof CustomVariableValue.String) && o.c(((CustomVariableValue.String) customVariableValue).getValue(), variable.getValue().g());
        }
        if (n.d(variable.getValue()) != null) {
            return (customVariableValue instanceof CustomVariableValue.Boolean) && Boolean.valueOf(((CustomVariableValue.Boolean) customVariableValue).getValue()).equals(n.d(variable.getValue()));
        }
        C value = variable.getValue();
        o.h(value, "<this>");
        if (S4.v.r0(value.g()) == null || !(customVariableValue instanceof CustomVariableValue.Number)) {
            return false;
        }
        double value2 = ((CustomVariableValue.Number) customVariableValue).getValue();
        C value3 = variable.getValue();
        o.h(value3, "<this>");
        Double dR0 = S4.v.r0(value3.g());
        return dR0 != null && value2 == dR0.doubleValue();
    }

    private static final <T extends PresentedPartial<T>> boolean shouldApply(PresentedOverride<T> presentedOverride, ScreenCondition screenCondition, OfferEligibility offerEligibility, ComponentViewState componentViewState, ConditionContext conditionContext) {
        List conditions = presentedOverride.getConditions();
        if (conditions != null && conditions.isEmpty()) {
            return true;
        }
        Iterator it = conditions.iterator();
        while (it.hasNext()) {
            if (!evaluate((ComponentOverride.Condition) it.next(), screenCondition, offerEligibility, componentViewState, conditionContext)) {
                return false;
            }
        }
        return true;
    }

    public static final Result toPresentedOverrides(List list, boolean z6, c transform) {
        o.h(list, "<this>");
        o.h(transform, "transform");
        if (z6) {
            ArrayList arrayList = new ArrayList();
            for (Object obj : list) {
                List<ComponentOverride.Condition> conditions = ((ComponentOverride) obj).getConditions();
                if (conditions == null || !conditions.isEmpty()) {
                    for (ComponentOverride.Condition condition : conditions) {
                        if (condition.isRule() || (condition instanceof ComponentOverride.Condition.Unsupported)) {
                            break;
                        }
                    }
                }
                arrayList.add(obj);
            }
            list = arrayList;
        }
        ArrayList arrayList2 = new ArrayList(AbstractC3253s.G(list, 10));
        for (ComponentOverride componentOverride : list) {
            Result result = (Result) transform.invoke(componentOverride.getProperties());
            if (!(result instanceof Result.Success)) {
                if (result instanceof Result.Error) {
                    return new Result.Error(((NonEmptyList) ((Result.Error) result).getValue()).getHead());
                }
                throw new v();
            }
            arrayList2.add(new PresentedOverride(componentOverride.getConditions(), (PresentedPartial) ((Result.Success) result).getValue()));
        }
        return new Result.Success(arrayList2);
    }

    public static /* synthetic */ Result toPresentedOverrides$default(List list, boolean z6, c cVar, int i6, Object obj) {
        if ((i6 & 1) != 0) {
            z6 = false;
        }
        return toPresentedOverrides(list, z6, cVar);
    }

    private static final boolean evaluate(ComponentOverride.Condition.IntroOfferRule introOfferRule, OfferEligibility offerEligibility) {
        boolean zIsIntroOffer = offerEligibility.isIntroOffer();
        int i6 = WhenMappings.$EnumSwitchMapping$0[introOfferRule.getOperator().ordinal()];
        if (i6 == 1) {
            return zIsIntroOffer == introOfferRule.getValue();
        }
        if (i6 == 2) {
            return zIsIntroOffer != introOfferRule.getValue();
        }
        throw new v();
    }

    private static final boolean evaluate(ComponentOverride.Condition.PromoOfferRule promoOfferRule, OfferEligibility offerEligibility) {
        boolean zIsPromoOffer = offerEligibility.isPromoOffer();
        int i6 = WhenMappings.$EnumSwitchMapping$0[promoOfferRule.getOperator().ordinal()];
        if (i6 == 1) {
            return zIsPromoOffer == promoOfferRule.getValue();
        }
        if (i6 == 2) {
            return zIsPromoOffer != promoOfferRule.getValue();
        }
        throw new v();
    }

    private static final boolean evaluate(ComponentOverride.Condition.SelectedPackage selectedPackage, String str) {
        if (str == null) {
            return false;
        }
        int i6 = WhenMappings.$EnumSwitchMapping$1[selectedPackage.getOperator().ordinal()];
        if (i6 == 1) {
            return selectedPackage.getPackages().contains(str);
        }
        if (i6 == 2) {
            return !selectedPackage.getPackages().contains(str);
        }
        throw new v();
    }

    private static final boolean evaluate(ComponentOverride.Condition.Variable variable, Map<String, ? extends CustomVariableValue> map) {
        CustomVariableValue customVariableValue = map.get(variable.getVariable());
        if (customVariableValue == null) {
            return variable.getOperator() == ComponentOverride.EqualityOperator.NOT_EQUALS;
        }
        boolean zMatchesValue = matchesValue(variable, customVariableValue);
        int i6 = WhenMappings.$EnumSwitchMapping$0[variable.getOperator().ordinal()];
        if (i6 == 1) {
            return zMatchesValue;
        }
        if (i6 == 2) {
            return !zMatchesValue;
        }
        throw new v();
    }
}