import store from "@/store";
import { storeActions } from "@/constants/store-actions.js";
import { storeMutations } from "@/constants/store-mutations.js";
import { sessionStorageKeyConstants } from "@/constants/session-storage.js";
import { navigationScenarios } from "@/router/constants/navigation-scenarios";
import { vehicleCategories } from "@/constants/vehicle-categories.js";
import { queryStrings } from "@/constants/query-strings";
import { dynamicStrings } from "@/constants/dynamic-strings";
import { partTypeStrings } from "../constants/part-type-strings";
import { showFmgLoadingModal } from "@/helpers/loading-modal-helper";
import { getItemsWithoutRecalParts } from "@/helpers/recal-helper";
import { debugLog } from "@/helpers/debug-log-helper";

export default {
    data() {
        return {
            cmsContentByWidget: {},
            _componentPageName: null,
        };
    },
    methods: {
        setCmsContent(cmsContent) {
            this.$root.cmsContentByWidget = cmsContent;
        },
        getCmsContent(widgetName, fieldName) {
            return this.$root.cmsContentByWidget?.[widgetName]?.[fieldName]
                ? this.$root.cmsContentByWidget[widgetName][fieldName]
                : "";
        },
        dispatchStoreAction(type, payload, encodePayload = true) {
            // Encode the payload if required
            if (encodePayload) {
                encodeUriData(payload);
            }

            return store.dispatch(type, payload);
        },
        dispatchStoreActionWithLogging(type, payload, pageNameToLog, encodePayload = true) {
            // Encode the payload if required
            if (encodePayload) {
                encodeUriData(payload);
            }

            const wrappedParams = {
                payload: payload,
                pageNameToLog: pageNameToLog,
            };

            return store.dispatch(type, wrappedParams);
        },
        savePageDataToStore(page, data) {
            store.commit(storeMutations.UPDATE_PAGE_DATA, { page: page, data: data });
        },
        onSubmit() {}, // DO NOT REMOVE; needed to prevent default form submit behavior. Cannot use .prevent modifier for vee-validate Form
        onInvalidSubmit({ values, errors, results }) {
            // identify the first error field and put focus on it
            // get error names array
            const errorNames = errors ? Object.keys(errors) : [];
            const firstErrorEl = errorNames[0];
            if (firstErrorEl) {
                const qsString = "[data-focus-target='" + firstErrorEl + "']";
                const el = document.querySelector(qsString);
                el && el.focus();
            }
        },
        getFooterInfoBoxHeight() {
            const footerInfoBox = document.querySelector(".footer#infoBox");
            return footerInfoBox ? footerInfoBox.offsetHeight : 0;
        },
        async getZipCodeData(zipCode, pageNameToLog = null) {
            const pageName = pageNameToLog ?? this.$options?.name;

            const serviceZipValidationResponse = await this.dispatchStoreActionWithLogging(
                storeActions.VALIDATE_ZIP,
                { zip: zipCode },
                pageName
            );

            return {
                containsMilitaryBase: serviceZipValidationResponse.data.containsMilitaryBase,
                isValid: serviceZipValidationResponse.data.isValid,
                isServiceable: serviceZipValidationResponse.data.isServiceable,
                state: serviceZipValidationResponse.data.state,
                zipCodeCtu: serviceZipValidationResponse.data.zipCodeCtu,
            };
        },
        getTierOnePackagePrice(lineItems) {
            let lineItemsToPrice = lineItems?.filter((lineItem) => {
                return (
                    lineItem.partType != partTypeStrings.FRONT_WIPER &&
                    lineItem.partType != partTypeStrings.REAR_WIPER &&
                    lineItem.partType != partTypeStrings.RAIN_REPEL
                );
            });

            let totalPrice = this.getTotalPriceOfAllLineItemsAndChildParts(lineItemsToPrice, false);
            // prettier-ignore
            {
                debugLog("base-mixin getTierOnePackagePrice lineItemsToPrice:", lineItemsToPrice);
                debugLog("base-mixin getTierOnePackagePrice totalPrice:", totalPrice);
            }
            return totalPrice;
        },
        filterOutFees(lineItems) {
            const filteredLineItems = lineItems?.filter((item) => {
                return (
                    (!item?.partType?.includes("FEE") && !item?.partType?.includes("EARLY BIRD")) ||
                    (item?.partType === "REPAIR FEE" && item?.partNumber != "SUPPLIES-REPAIR")
                );
            });
            return filteredLineItems;
        },
        filterOutCertainPartTypesOrNumbers(
            lineItemsArray,
            { partTypesToRemove = [], partNumbersToRemove = [] }
        ) {
            // lineItems s/b an ARRAY here
            if (!Array.isArray(lineItemsArray)) return;

            partTypesToRemove.forEach((partType) => {
                lineItemsArray = lineItemsArray.filter((item) => {
                    return !item?.partType?.includes(partType);
                });
            });
            partNumbersToRemove.forEach((partNumber) => {
                lineItemsArray = lineItemsArray.filter((item) => {
                    return !item?.partNumber?.includes(partNumber);
                });
            });
            return lineItemsArray;
        },
        filterOutQuotePageDiscountPart(lineItems) {
            const filteredLineItems = lineItems?.filter((item) => {
                return !item?.partType?.includes(partTypeStrings.QUOTE_PAGE_DISCOUNT);
            });
            return filteredLineItems;
        },
        filterOutRecalibration(lineItems) {
            return getItemsWithoutRecalParts(lineItems);
        },
        getTotalPriceOfAllLineItemsAndChildParts(lineItems, includeTax) {
            let totalPrice = 0;
            lineItems?.forEach((lineItem) => {
                totalPrice += this.getTotalLineItemPrice(lineItem, includeTax);
                if (lineItem.childParts) {
                    totalPrice += this.getTotalPriceOfAllLineItemsAndChildParts(
                        lineItem.childParts,
                        includeTax
                    );
                }
            });
            return totalPrice;
        },
        getTotalLineItemPrice(lineItem, includeTax) {
            const kitPrice = lineItem.kitPrice ?? 0;
            const laborAmount = lineItem.laborAmount ?? 0;
            const sellingPrice = lineItem.sellingPrice ?? 0;
            const salesTax = lineItem.salesTax ?? 0;

            if (includeTax) {
                return kitPrice + laborAmount + sellingPrice + salesTax;
            } else {
                return kitPrice + laborAmount + sellingPrice;
            }
        },

        scrollToPageTop() {
            const container = document.getElementsByClassName("page-container-grouped-styles")[0];
            container.scrollTo({ top: 0, left: 0, behavior: "smooth" });
        },
        scrollToPageBottom() {
            const container = document.getElementsByClassName("page-container-grouped-styles")[0];
            container.scrollTo({ top: container.scrollHeight, left: 0, behavior: "smooth" });
        },
        ResetExternalParamsAndHideModal() {
            this.dispatchStoreAction(storeActions.RESET_EXTERNAL_PARAMETER_STATE);
            showFmgLoadingModal(false);
        },
        async isFormValid(form) {
            const formValidateResponse = await form?.validate();
            return formValidateResponse?.valid;
        },
        showApplePay() {
            var iOSversion = this.getiOSversion();
            var isMacOS = navigator.platform.indexOf("Mac") !== -1;
            if (isMacOS || (iOSversion && iOSversion[0] >= 17)) {
                if (window.ApplePaySession && window.ApplePaySession.canMakePayments()) {
                    return true;
                }
            }
            return false;
        },
        getiOSversion() {
            if (/iP(hone|od|ad)/.test(navigator.platform)) {
                // supports iOS 2.0 and later:
                var v = navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
                return [parseInt(v[1], 10), parseInt(v[2], 10), parseInt(v[3] || 0, 10)];
            }
        },
        isMobileDevice() {
            const userAgent = navigator.userAgent;
            return (
                userAgent.includes("Android") ||
                userAgent.includes("Mobile") ||
                userAgent.includes("iPod") ||
                userAgent.includes("iPhone") ||
                userAgent.includes("IEMobile") ||
                userAgent.includes("BlackBerry") ||
                userAgent.includes("webOS")
            );
        },
        isAppleBrowser() {
            const userAgent = navigator.userAgent;
            return (
                userAgent.includes("iPod") ||
                userAgent.includes("iPad") ||
                userAgent.includes("iPhone") ||
                userAgent.includes("Mac")
            );
        },
        getSubmittedOrder() {
            return JSON.parse(
                window.sessionStorage.getItem(sessionStorageKeyConstants.SUBMITTED_STATE)
            )?.order;
        },
        hasSubmittedOrder() {
            const submittedState = window.sessionStorage.getItem(
                sessionStorageKeyConstants.SUBMITTED_STATE
            );
            return submittedState !== null && submittedState.order !== null;
        },
        getSubmittedApplicationUser() {
            return JSON.parse(
                window.sessionStorage.getItem(sessionStorageKeyConstants.SUBMITTED_STATE)
            )?.applicationUser;
        },
        hasSubmittedApplicationUser() {
            const submittedState = window.sessionStorage.getItem(
                sessionStorageKeyConstants.SUBMITTED_STATE
            );
            return submittedState !== null && submittedState.applicationUser !== null;
        },
    },
    computed: {
        storeActions() {
            return storeActions;
        },
        storeMutations() {
            return storeMutations;
        },
        navigationScenarios() {
            return navigationScenarios;
        },
        vehicleCategories() {
            return vehicleCategories;
        },
        queryStrings() {
            return queryStrings;
        },
        dynamicStrings() {
            return dynamicStrings;
        },
        cssClassNameForCmsWidget() {
            return "widget-name-" + this.cmsWidgetName;
        },
        pageName() {
            return this._componentPageName ?? this.$route.name;
        },
    },

    mounted() {
        // Store route immutably so that components know their originating page even during page transition.
        this._componentPageName = this.$route.name;

        if (!store.getters.externalParameterState?.isExternalParameter) {
            showFmgLoadingModal(false);
        }
    },
};

function encodeUriData(payload) {
    if (payload && Object.keys(payload).length > 0) {
        // Loop through the payload and encode the values
        Object.keys(payload).forEach((key) => {
            payload[key] = encodeURIComponent(payload[key]);
        });
    }
}