const onSubmitLoyaltyPromoCode = useCallback(async () => {
    setPromoCodeValidationLoading(true);

    // const loyaltyId = 'ec5cec01-b41b-509b-9111-310ab5a18154';

    let event = createRbiApplyPromoCodeEvent(promoCodeInput, 'Successful');
    const personalizedOffer = await redeemMutation(user?.loyaltyId || '', promoCodeInput)
      .catch((e: PromoCodeError) => {
        const reason = buildErrorMessageFromPromoCodeError(e);
        setPromoCodeErrorMessageId(
          (reason as TPromoCodeErrorMessageIds) || PromoCodeErrorMessageIds.default
        );

        logger.error(`Error validating promo code ${e}`);
        event = createRbiApplyPromoCodeEvent(promoCodeInput, 'Failed', e.message);
      })
      .finally(() => {
        setPromoCodeValidationLoading(false);
      });

    trackEvent(event);

    if (personalizedOffer) {
      await handleRedemption(personalizedOffer);

      // clear promo code input & error message
      setPromoCodeErrorMessageId(null);
      setPromoCodeInput('');

      toast.success(formatMessage({ id: 'offerAddedToCart' }));
    }
  }, [
    formatMessage,
    handleRedemption,
    promoCodeInput,
    redeemMutation,
    trackEvent,
    user?.loyaltyId,
  ]);
  
  
   useEffect(() => {
    if (appliedOfferPromoCode?.loyaltyEngineId) {
      const standardOffersLimit =
        earningCalculationData?.EarningCalculation?.offerRedemptionLimits?.standardOffersLimit || 1;

      dispatch(actions.loyalty.setSelectedOffer(appliedOfferPromoCode));
      dispatch(actions.loyalty.setAppliedOffers([appliedOfferPromoCode]));

      if (isDiscountLoyaltyOffer(appliedOfferPromoCode)) {
        // If limit of offers reached remove the first one
        if (appliedOffers?.length >= standardOffersLimit) {
          removeFromCart({ cartId: appliedOffers[0].cartId });
        }

        //Discount offers should not show menu item details
        dispatch(
          actions.loyalty.applyOffer({
            id: appliedOfferPromoCode.loyaltyEngineId,
            type: OfferType.GLOBAL,
            isStackable: appliedOfferPromoCode.isStackable,
            isSurprise: isSurpriseOffer(appliedOfferPromoCode),
            cmsId: appliedOfferPromoCode._id,
            cartId: 'discount-offer',
          })
        );
      }

      dispatch(actions.loyalty.setCmsOffers([appliedOfferPromoCode]));
      return;
    }

    dispatch(actions.loyalty.setSelectedOffer(null));
    dispatch(actions.loyalty.setAppliedOffers([]));
    dispatch(actions.loyalty.setCmsOffers([]));

    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [appliedOfferPromoCode]);

useEffect(() => {
  if (!loading && !orderErrors) {
    dispatch(actions.loyalty.setSelectedOffer(null));
    dispatch(actions.loyalty.setAppliedOffers([]));
    dispatch(actions.loyalty.setCmsOffers([]));
  }
}, [dispatch, loading, orderErrors]);

getSystemWideOfferIncentiveDiscountAndType(offerId) {
    return this.reader.fetch(`
  *[_type == "systemwideOffer"
    && _id == $offerId
    && defined(incentives[_type == 'offerDiscount'][0])][0] {
      incentives[0]-> {
        discountType,
        discountValue
      }
    }
  `, { offerId });
}

getLoyatyConfigOfferType(offerId) {
  return this.reader.fetch(`
  *[_type == "configOffer"
    && _id == $offerId
    && defined(incentives[_type == 'offerDiscount'][0])][0] {
      incentives[0]-> {
        discountType,
        discountValue
      }
    }
  `, { offerId });
}

 /**
   * Calculates cart total.
   *
   * @param {ICart} cart Contents of the cart.
   * @returns {Promise<number>} A cart total.
   */
  public async calculate(cart: ICart): Promise<number> {
    // our base will be a simple sum of prices of all items
    let total = cart.cartEntries.reduce((sum: number, current: ICartEntry) => {
      if (current.price) {
        // even though we have price for entire item already we need to look for premium items which are not included
        const premiumItemsPrice = this.pricePremiumItems(current);
        return sum + current.price + premiumItemsPrice;
      }
      return sum + this.priceCartItem(current);
    }, 0);

    this.logger.debug({ total }, `Base total calculated`);

    // apply discount (we assume that there cannot be more than one)
    const discountEntry = cart.cartEntries.find(
      (entry: ICartEntry) => entry.type === CartEntryType.offerDiscount,
    );

    if (discountEntry) {
      const { sanityId } = discountEntry;

      const offer = await this.sanityLoyalty.getSystemWideOfferIncentiveDiscountAndType(sanityId);

      if (offer) {
        const { discountValue } = offer.incentives;
        this.logger.debug({ discountValue, sanityId }, 'Applying discount (system wide offer)');
        total = total - Math.round((total * discountValue) / 100);
      } else {
        this.logger.warn({ sanityId }, 'Offer not found in sanity');
      }
    }

    this.logger.info({ total }, 'Cart total calculated');

    return total;
  }

/**
   * Calculates cart total.
   *
   * @param {ICart} cart Contents of the cart.
   * @returns {Promise<number>} A cart total.
   */
  public async calculate(cart: ICart): Promise<ICart> {
    // apply discount (we assume that there cannot be more than one)
    const discountEntry = cart.cartEntries.find(
      (entry: ICartEntry) => entry.type === CartEntryType.offerDiscount,
    );
    
    const cartEntriesWithDiscount = cart.cartEntries.filter(
      (entry: ICartEntry) => entry.type !== CartEntryType.offerDiscount,
    );

    let offerSystemWide = {} as IRewardIncentive | undefined;
    let configOffer = {} as ILoyatyConfigOffer | undefined;

    if (discountEntry) {
      const { sanityId } = discountEntry;
      offerSystemWide = await this.sanityLoyalty.getSystemWideOfferIncentiveDiscountAndType(
        sanityId,
      );
      configOffer = await this.sanityLoyalty.getLoyatyConfigOfferType(sanityId);
    }

    const cartDiscounted = cart.cartEntries.map((cartEntrie: ICartEntry) => {
      if (cartEntrie.type === CartEntryType.offerDiscount) {
        return cartEntrie;
      }

      const discountPromo = offerSystemWide?.incentives || configOffer?.incentives;
      if (cartEntrie.price && discountPromo) {
        const { discountValue, discountType } = discountPromo;
        return {
          ...cartEntrie,
          price: this.calDiscount({
            description: offerSystemWide?.incentives
              ? '(system wide offer)'
              : configOffer?.incentives
              ? '(config offer)'
              : '',
            discountType,
            discountValue,
            length: cartEntriesWithDiscount.length,
            value: cartEntrie.price,
          }),
        };
      }
      return cartEntrie;
    });

    cart.cartEntries = cartDiscounted;

    // our base will be a simple sum of prices of all items
    const total = cart.cartEntries.reduce((sum: number, current: ICartEntry) => {
      if (current.type === CartEntryType.offerDiscount) {
        return sum;
      }

      if (current.price) {
        // even though we have price for entire item already we need to look for premium items which are not included
        const premiumItemsPrice = this.pricePremiumItems(current);
        return sum + current.price + premiumItemsPrice;
      }
      return sum + this.priceCartItem(current);
    }, 0);

    const cartUpdated = {
      ...cart,
      subTotalCents: total,
      totalCents: total,
    };

    return cartUpdated;
  }
  
  
  
  
private calDiscount({
    discountValue,
    discountType,
    value,
    length,
    description,
  }: {
    discountValue: number;
    discountType: string;
    value: number;
    length: number;
    description?: string;
  }): number {
    switch (discountType) {
      case 'amount':
        value = value - Math.round((discountValue * 100) / length);
        break;
      default:
        value = value - Math.round((value * discountValue) / 100);
        break;
    }
    this.logger.debug({ discountType, discountValue }, `Applied discount ${description}`);
    return value;
  }