import store from "@/store";
import { storeActions } from "@/constants/store-actions";
import { partTypeStrings } from "@/constants/part-type-strings";
import { deepClone } from "@/helpers/object-helper";
import baseMixin from "@/mixins/base-mixin.js";

export const promoPartNumberStrings = {
    WIPER_DISCOUNT_PART_NUMBER: "WIPER DISCOUNT",
    RAIN_DEFENSE_DISCOUNT_PART_NUMBER: "DISC RAIN DEFEN",
    GLASS_DISCOUNT_PART_NUMBER: "DISCOUNT",
    GLASS_CLEANER_DISCOUNT_PART_NUMBER: "DISC GLASS CLN",
};

export const addableVapsPromoPartNumbers = [
    promoPartNumberStrings.RAIN_DEFENSE_DISCOUNT_PART_NUMBER,
    promoPartNumberStrings.WIPER_DISCOUNT_PART_NUMBER,
];

export const pagesToStripPromoQueryStringFrom = ["quote", "payment-method"];

export function getPromosWithAddableVaps(promoList) {
    if (!promoList.length) {
        return [];
    }

    return promoList.filter((promo) => addableVapsPromoPartNumbers.includes(promo.partNumber));
}

export function getLineItemsThatMatchPromos(promos, availableLineItems) {
    const matchingLineItems = [];
    promos.forEach((promo) => {
        promo.discountedLineItemIds.forEach((discountedLineItemId) => {
            matchingLineItems.push(
                ...availableLineItems.filter((lineItem) => lineItem.id === discountedLineItemId)
            );
        });
    });
    return matchingLineItems;
}

// Note: Addable VAPs for the Promo Validation endpoint can also be on the order already
//         There is no need to only send un-added VAPs in this array.
export function getAddableVapsFromAvailableLineItems(availableLineItems) {
    const addableVaps = [];
    addableVaps.push(...findLineItemsWithPartType(partTypeStrings.FRONT_WIPER, availableLineItems));
    addableVaps.push(
        ...findLineItemsWithPartType(partTypeStrings.RAIN_DEFENSE, availableLineItems)
    );
    return addableVaps;
}

export function removeVapsPromosFromPromoArray(promoArray) {
    if (!promoArray) {
        return [];
    }
    const filteredPromoArray = promoArray.filter((promo) => {
        return (
            promo.partNumber != promoPartNumberStrings.WIPER_DISCOUNT_PART_NUMBER &&
            promo.partNumber != promoPartNumberStrings.RAIN_DEFENSE_DISCOUNT_PART_NUMBER &&
            promo.partNumber != promoPartNumberStrings.GLASS_CLEANER_DISCOUNT_PART_NUMBER
        );
    });
    return filteredPromoArray;
}

export async function revalidatePromosAndValidateNewPromo(
    newPromo,
    pricedLineItems,
    pageNameToLog
) {
    const hasActivePromos = store.getters.order.lineItems.promos;
    const hasHasInactivePromos = store.getters.order.lineItems.inactivePromos;
    const hasNewPromo = !!newPromo;
    const addableVaps = getAddableVapsFromAvailableLineItems(pricedLineItems);

    let validatePromoResponse = null;
    let revalidatePromoResponse = null;

    if (hasActivePromos || hasHasInactivePromos) {
        revalidatePromoResponse = await baseMixin.methods.dispatchStoreActionWithLogging(
            storeActions.REVALIDATE_ORDER_PROMOS_AND_SAVE_SERVER_DATA,
            {},
            pageNameToLog,
            false
        );
        baseMixin.methods.dispatchStoreAction(
            storeActions.SAVE_PROMOS,
            revalidatePromoResponse.promoLineItems,
            false
        );
        const revalidationErrorPromoCodes = revalidatePromoResponse.errors.map((x) => x.promoCode);
        baseMixin.methods.dispatchStoreAction(
            storeActions.SAVE_INACTIVE_PROMOS,
            revalidationErrorPromoCodes,
            false
        );
    }
    if (hasNewPromo) {
        validatePromoResponse = await baseMixin.methods.dispatchStoreActionWithLogging(
            storeActions.VALIDATE_ORDER_PROMO_AND_SAVE_SERVER_DATA,
            {
                promoCode: newPromo,
                addableVaps: addableVaps,
            },
            pageNameToLog,
            false
        );
    }

    return { validatePromoResponse, revalidatePromoResponse };
}

export function getPromosThatMatchLineItemsOnOrder(promos, lineItemsOnOrder) {
    const matchingPromos = [];
    promos.forEach((promo) => {
        let allIdsMatch = true;
        promo.discountedLineItemIds.forEach((id) => {
            if (lineItemsOnOrder.filter((x) => x.id === id).length === 0) {
                allIdsMatch = false;
                return;
            }
        });
        if (allIdsMatch) {
            matchingPromos.push(promo);
        }
    });
    return matchingPromos;
}

// Returns the vaps that the provided <promos> requires to be on the order to satisfy
//  Items that are already in <lineItemsOnOrder> will not be returned
export function getVapsThatNeedToBeAddedToSatisfyPromos(
    promos,
    availableLineItems,
    lineItemsOnOrder
) {
    const clonedVaps = deepClone(lineItemsOnOrder.vaps ?? []);
    const promosWithAddableVaps = getPromosWithAddableVaps(promos);
    if (promosWithAddableVaps.length) {
        const matchingLineItems = getLineItemsThatMatchPromos(
            promosWithAddableVaps,
            availableLineItems
        );
        // Check if matching items are already in the order
        const idsOfVapsAlreadyInOrder = clonedVaps.map((lineItem) => lineItem.id);
        const vapsToAddToCart = matchingLineItems.filter(
            (lineItem) => !idsOfVapsAlreadyInOrder.includes(lineItem.id)
        );
        return vapsToAddToCart;
    } else {
        return [];
    }
}

export function shouldStripPromoQueryString(fmgPageQueryValue) {
    return pagesToStripPromoQueryStringFrom.includes(fmgPageQueryValue);
}

// private methods
function findLineItemsWithPartType(typeToFind, itemsToSearch) {
    const partTypeMatches = itemsToSearch?.filter(
        (lineItem) => lineItem.partType.toUpperCase() === typeToFind.toUpperCase()
    );
    return partTypeMatches;
}