adminFront/src/kitUI/Cart/calc.ts

import { CartItem, AnyDiscount, CartTotal, CartItemTotal, PrivilegeDiscount, CartPurchasesAmountDiscount, PurchasesAmountDiscount, ServiceToPriceMap, ServiceDiscount, UserDiscount } from "@root/model/cart";
import { ServiceType, SERVICE_LIST, Tariff } from "../../model/tariff";
import { User } from "../../model/user";


export function calcCartData(
    user: User,
    cartItems: CartItem[],
    discounts: AnyDiscount[],
    isNonCommercial: boolean = false,
    coupon?: string,
): CartTotal | Error | null {
    let isIncompatibleTariffs = false;

    const defaultTariffTypePresent: { [Key in ServiceType]: boolean } = {
        dwarfener: false,
        squiz: false,
        templategen: false,
    };

    cartItems.forEach(cartItem => {
        if (cartItem.tariff.customPricePerUnit === undefined) return defaultTariffTypePresent[cartItem.tariff.privilege.serviceKey] = true;

        if (
            defaultTariffTypePresent[cartItem.tariff.privilege.serviceKey] &&
            cartItem.tariff.customPricePerUnit !== undefined
        ) isIncompatibleTariffs = true;
    });

    if (isIncompatibleTariffs) return new Error("Если взят готовый тариф, то кастомный на этот сервис сделать уже нельзя");

    if (!cartItems.length) return null;

    const cartTotal: CartTotal = {
        items: [],
        totalPrice: 0,
        priceByService: {
            templategen: 0,
            squiz: 0,
            dwarfener: 0,
        },
        discountsByService: {
            templategen: null,
            squiz: null,
            dwarfener: null,
        },
        envolvedCartDiscounts: [],
        couponState: coupon ? "not found" : null,
    };

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

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

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

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

        return cartTotal;
    }

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

    // layer 1
    for (const cartItem of cartItems) {
        const cartItemTotal: 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) return;
            if (tariff.customPricePerUnit !== undefined && !couponDiscount.overwhelm) return;

            cartItemTotal.totalPrice *= product.factor;
            cartItemTotal.envolvedDiscounts.push(couponDiscount);
            cartTotal.couponState = "applied";
            privilegesAffectedByCoupon.push(product.privilegeId);
        });

        const privilegeDiscount = findMaxApplicablePrivilegeDiscount(discounts, tariff);

        privilegeDiscount?.target.products.forEach(product => {
            if (product.privilegeId !== tariff.privilege.privilegeId) return;
            if (tariff.customPricePerUnit !== undefined) return;
            if (privilegesAffectedByCoupon.includes(privilegeDiscount.condition.privilege.id)) return;

            cartItemTotal.totalPrice *= product.factor;
            cartItemTotal.envolvedDiscounts.push(privilegeDiscount);
        });

        cartTotal.items.push(cartItemTotal);
        cartTotal.priceByService[tariff.privilege.serviceKey] += cartItemTotal.totalPrice;
    }

    // layer 2
    SERVICE_LIST.map(service => service.serviceKey).forEach(service => {
        const serviceDiscount = findMaxServiceDiscount(service, discounts, cartTotal.priceByService);
        if (serviceDiscount) {
            cartTotal.priceByService[service] *= serviceDiscount.target.factor;
            cartTotal.discountsByService[service] = serviceDiscount;
        }

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

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

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

    return cartTotal;
}

function findMaxApplicablePrivilegeDiscount(discounts: AnyDiscount[], tariff: Tariff): PrivilegeDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is 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: AnyDiscount[], cartTotal: CartTotal): CartPurchasesAmountDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is 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: AnyDiscount[], purchasesAmount: number): PurchasesAmountDiscount | null {
    const applicableDiscounts = discounts.filter((discount): discount is PurchasesAmountDiscount => {
        return discount.conditionType === "purchasesAmount" && 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: ServiceType,
    discounts: AnyDiscount[],
    priceByService: ServiceToPriceMap,
): ServiceDiscount | null {
    const discountsForTariffService = discounts.filter((discount): discount is ServiceDiscount => {
        return (
            discount.conditionType === "service" &&
            discount.condition.service.id === service &&
            priceByService[service] >= 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: AnyDiscount[], user: User, coupon: string,): UserDiscount | null {
    const userDiscount = discounts.find((discount): discount is UserDiscount => {
        return (
            discount.conditionType === "user" &&
            discount.condition.user === user.ID &&
            discount.condition.coupon === coupon
        );
    });

    return userDiscount ?? null;
}

export function createCartItem(tariff: Tariff): CartItem {
    const pricePerUnit = tariff.customPricePerUnit ?? tariff.privilege.pricePerUnit;
    const price = pricePerUnit * tariff.amount;

    return { tariff, price, id: "someId" };
}

export function findDiscountFactor(discount: AnyDiscount, privilegeId?: string) {
    switch (discount.conditionType) {
        case "cartPurchasesAmount":
            return discount.factor;
        case "purchasesAmount":
            return discount.factor;
        case "privilege": {
            const product = discount.target.products.find(product => product.privilegeId === privilegeId);
            if (!product) throw new Error("Discount target product not found");

            return product.factor;
        }
        case "user": {
            const product = discount.target.products.find(product => product.privilegeId === privilegeId);
            if (!product) throw new Error("Discount target product not found");

            return product.factor;
        }
        case "service":
            return discount.target.factor;
        case "userType":
            return discount.target.factor;
    }
}

export function formatDiscountFactor(factor: number): string {
    return `${((1 - factor) * 100).toFixed(1)}%`;
}