adminFront/src/pages/dashboard/Content/Tariffs/cartCalcs.ts

import { Cart } from "../../../../model/cart";
import { SERVICE_LIST, Tariffs } from "../../../../model/tariff";
import { User } from "../../../../model/user";


export function calcCartData(
    user: User,
    cartItems: Cart.CartItem[],
    discounts: Cart.AnyDiscount[],
    coupon?: string,
): Cart.CartTotal {
    const cartTotal: Cart.CartTotal = {
        items: [],
        totalPrice: 0,
        priceByService: {
            templategen: {
                defaultTariffs: 0,
                customTariffs: 0,
            },
            squiz: {
                defaultTariffs: 0,
                customTariffs: 0,
            },
            dwarfener: {
                defaultTariffs: 0,
                customTariffs: 0,
            },
        },
        envolvedCartDiscounts: [],
    };

    // layer 0
    for (const discount of discounts) {
        if (discount.conditionType !== "userType" || discount.condition.userType !== user.Type) continue;

        cartItems.forEach(cartItem => {
            cartTotal.items.push({
                envolvedDiscounts: [],
                tariff: cartItem.tariff,
                totalPrice: cartItem.price,
            });

            cartTotal.priceByService[cartItem.tariff.privilege.serviceKey].defaultTariffs += cartItem.price;
            cartTotal.totalPrice += cartItem.price;
        });

        cartTotal.totalPrice *= discount.target.factor;
        cartTotal.envolvedCartDiscounts.push(discount._id);

        return cartTotal;
    }

    const couponDiscount = coupon ? findUserDiscount(discounts, user, coupon) : null;

    // layer 1
    for (const cartItem of cartItems) {
        const cartItemTotal: Cart.CartItemTotal = {
            tariff: cartItem.tariff,
            envolvedDiscounts: [],
            totalPrice: cartItem.price,
        };

        const tariff = cartItem.tariff;
        const privilegesAffectedByCoupon: string[] = [];

        couponDiscount?.target.products.forEach(product => {
            if (
                product.privilegeId === tariff.privilege.privilegeId &&
                (tariff.customPricePerUnit === undefined || couponDiscount.overwhelm)
            ) {
                cartItemTotal.totalPrice *= product.factor;
                cartItemTotal.envolvedDiscounts.push(couponDiscount._id);
                privilegesAffectedByCoupon.push(product.privilegeId);
            }
        });

        const privilegeDiscount = findMaxApplicablePrivilegeDiscount(discounts, tariff);

        privilegeDiscount?.target.products.forEach(product => {
            if (
                product.privilegeId === tariff.privilege.privilegeId &&
                tariff.customPricePerUnit === undefined &&
                !privilegesAffectedByCoupon.includes(privilegeDiscount.condition.privilege.id)
            ) {
                cartItemTotal.totalPrice *= product.factor;
                cartItemTotal.envolvedDiscounts.push(privilegeDiscount._id);
            }
        });

        cartTotal.items.push(cartItemTotal);
        if (tariff.customPricePerUnit === undefined) cartTotal.priceByService[tariff.privilege.serviceKey].defaultTariffs += cartItemTotal.totalPrice;
        else cartTotal.priceByService[tariff.privilege.serviceKey].customTariffs += cartItemTotal.totalPrice;
    }

    // layer 2
    SERVICE_LIST.forEach(service => {
        const serviceDiscount = findMaxServiceDiscount(service, discounts, cartTotal.priceByService);
        if (serviceDiscount) {
            cartTotal.priceByService[service].defaultTariffs *= serviceDiscount.target.factor;
            cartTotal.envolvedCartDiscounts.push(serviceDiscount._id);
        }

        cartTotal.totalPrice += cartTotal.priceByService[service].defaultTariffs;
        cartTotal.totalPrice += cartTotal.priceByService[service].customTariffs;
    });

    // layer 3
    const cartPurchasesAmountDiscount = findMaxCartPurchasesAmountDiscount(discounts, cartTotal);
    if (cartPurchasesAmountDiscount) {
        cartTotal.totalPrice *= cartPurchasesAmountDiscount.factor;
        cartTotal.envolvedCartDiscounts.push(cartPurchasesAmountDiscount._id);
    }

    // layer 4
    const totalPurchasesAmountDiscount = findMaxTotalPurchasesAmountDiscount(discounts, user);
    if (totalPurchasesAmountDiscount) {
        cartTotal.totalPrice *= totalPurchasesAmountDiscount.factor;
        cartTotal.envolvedCartDiscounts.push(totalPurchasesAmountDiscount._id);
    }

    return cartTotal;
}

function findMaxApplicablePrivilegeDiscount(discounts: Cart.AnyDiscount[], tariff: Tariffs.Tariff): Cart.PrivilegeDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is Cart.PrivilegeDiscount => {
        return (
            discount.conditionType === "privilege" &&
            tariff.privilege.privilegeId === discount.condition.privilege.id &&
            tariff.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;
}

function findMaxCartPurchasesAmountDiscount(discounts: Cart.AnyDiscount[], cartTotal: Cart.CartTotal): Cart.CartPurchasesAmountDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is Cart.CartPurchasesAmountDiscount => {
        return discount.conditionType === "cartPurchasesAmount" && cartTotal.totalPrice >= discount.condition.cartPurchasesAmount;
    });

    if (!applicableDiscounts.length) return null;

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

    return maxValueDiscount;
}

function findMaxTotalPurchasesAmountDiscount(discounts: Cart.AnyDiscount[], user: User): Cart.PurchasesAmountDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is Cart.PurchasesAmountDiscount => {
        return discount.conditionType === "purchasesAmount" && user.PurchasesAmount >= discount.condition.purchasesAmount;
    });

    if (!applicableDiscounts.length) return null;

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

    return maxValueDiscount;
}

function findMaxServiceDiscount(
    service: Tariffs.ServiceType,
    discounts: Cart.AnyDiscount[],
    priceByService: Cart.ServiceToPriceMap,
): Cart.ServiceDiscount | null {
    const discountsForTariffService = discounts.filter((discount): discount is Cart.ServiceDiscount => {
        return (
            discount.conditionType === "service" &&
            discount.condition.service.id === service &&
            priceByService[service].defaultTariffs + priceByService[service].customTariffs >= 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;
}

function findUserDiscount(discounts: Cart.AnyDiscount[], user: User, coupon: string,): Cart.UserDiscount | null {
    const userDiscount = discounts.find((discount): discount is Cart.UserDiscount => {
        return (
            discount.conditionType === "user" &&
            discount.condition.user === user.ID &&
            discount.condition.coupon === coupon
        );
    });

    return userDiscount ?? null;
}