front-hub/src/utils/calcTariffPrices.ts

import { Tariff } from "@root/model/tariff";
import { PrivilegeMap} from "@root/model/privilege";
import { PrivilegeWithAmount } from "@root/model/privilege";
import { AnyDiscount, PrivilegeDiscount, ServiceDiscount, CartPurchasesAmountDiscount, PurchasesAmountDiscount } from "../model/discount";
import { useCartStore } from "@root/stores/cart";
import { useUserStore } from "@root/stores/user";

export function calcTariffPrices(tariff: Tariff, discounts: AnyDiscount[], privilegies: PrivilegeMap): {
    price: number | undefined;
    priceWithDiscounts: number | undefined;
} {
    let price = tariff.price || tariff.privilegies.reduce((sum, privilege) => sum + privilege.amount * privilege.price, 0);
    
    console.log(useCartStore.getState().cart)

    let priceWithDiscounts = tariff.privilegies.reduce((sum, privilege) => {
        let privilegePrice = privilege.amount * privilege.price;
        let realprivilegie = privilegies[privilege.serviceKey].find(e => e._id === privilege.privilegeId)
        if (realprivilegie) privilege.privilegeId = realprivilegie.privilegeId
        const privilegeDiscount = findPrivilegeDiscount(privilege, discounts);
        if (privilegeDiscount) privilegePrice *= privilegeDiscount.target.products[0].factor;
        const serviceCartData = useCartStore.getState().cart.services.find(e => e.serviceKey === privilege.serviceKey);
        let serviceprice = 0;
        if (serviceCartData) serviceprice = serviceCartData.price;

        const serviceDiscount = findServiceDiscount(privilege.serviceKey, privilegePrice + serviceprice, discounts);
        if (serviceDiscount) privilegePrice *= serviceDiscount.target.factor;

        return sum + privilegePrice;
    }, 0);

    const cartDiscount = findCartDiscount(priceWithDiscounts + useCartStore.getState().cart.priceAfterDiscounts, discounts);
    if (cartDiscount) priceWithDiscounts *= cartDiscount.factor;

    const acc = useUserStore.getState();
    const loyalDiscount = findLoyalDiscount(acc!.userAccount!.wallet.purchasesAmount, discounts);
    if (loyalDiscount) priceWithDiscounts *= loyalDiscount.factor;


    return {
        price,
        priceWithDiscounts,
    };
}

export function findPrivilegeDiscount(privilege: PrivilegeWithAmount, discounts: AnyDiscount[]): PrivilegeDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is PrivilegeDiscount => {
        return (
            discount.conditionType === "privilege" &&
            privilege.privilegeId === discount.condition.privilege.id &&
            privilege.amount >= discount.condition.privilege.value
        );
    });

    if (!applicableDiscounts.length) return null;

    const maxValueDiscount = applicableDiscounts.reduce((prev, current) =>
        current.condition.privilege.value > prev.condition.privilege.value ? current : prev
    );

    return maxValueDiscount;
}

export function findServiceDiscount(
    serviceKey: string,
    currentPrice: number,
    discounts: AnyDiscount[],
): ServiceDiscount | null {
    const discountsForTariffService = discounts.filter((discount): discount is ServiceDiscount => {
        return (
            discount.conditionType === "service" &&
            discount.condition.service.id === serviceKey &&
            currentPrice >= discount.condition.service.value
        );
    });

    if (!discountsForTariffService.length) return null;

    const maxValueDiscount = discountsForTariffService.reduce((prev, current) => {
        return current.condition.service.value > prev.condition.service.value ? current : prev;
    });

    return maxValueDiscount;
}

export function findCartDiscount(
  currentPrice: number,
  discounts: AnyDiscount[],
): CartPurchasesAmountDiscount | null {
  const discountsForCart = discounts.filter((discount) : discount is CartPurchasesAmountDiscount => {
    return (
      discount.conditionType === "cartPurchasesAmount" &&
      currentPrice >= discount.condition.cartPurchasesAmount
    )
  })

  if (!discountsForCart.length) return null;

  const maxValueDiscount = discountsForCart.reduce((prev, current) => {
    return current.condition.cartPurchasesAmount > prev.condition.cartPurchasesAmount ? current : prev;
  })

  return maxValueDiscount;
}

export function findLoyalDiscount(
  currentPrice: number,
  discounts: AnyDiscount[],
): PurchasesAmountDiscount | null {
  const discountsForCart = discounts.filter((discount) : discount is PurchasesAmountDiscount => {
    return (
      discount.conditionType === "purchasesAmount" &&
      currentPrice >= discount.condition.purchasesAmount
    )
  })

  if (!discountsForCart.length) return null;

  const maxValueDiscount = discountsForCart.reduce((prev, current) => {
    return current.condition.purchasesAmount > prev.condition.purchasesAmount ? current : prev;
  })

  return maxValueDiscount;
}